diff --git a/Casadi/Core/Classes/Callback.hs b/Casadi/Core/Classes/Callback.hs --- a/Casadi/Core/Classes/Callback.hs +++ b/Casadi/Core/Classes/Callback.hs @@ -9,13 +9,15 @@ ( Callback, CallbackClass(..), - callback, + callback__0, + callback__1, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -23,29 +25,48 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__Callback__CONSTRUCTOR" c_casadi__Callback__CONSTRUCTOR +foreign import ccall unsafe "casadi__Callback__CONSTRUCTOR__0" c_casadi__Callback__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr IterationCallback' -> IO (Ptr Callback') +casadi__Callback__CONSTRUCTOR__0 + :: IterationCallback -> IO Callback +casadi__Callback__CONSTRUCTOR__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback__CONSTRUCTOR__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback__0 :: IterationCallback -> IO Callback +callback__0 = casadi__Callback__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback__CONSTRUCTOR__1" c_casadi__Callback__CONSTRUCTOR__1 :: Ptr (Ptr StdString) -> IO (Ptr Callback') -casadi__Callback__CONSTRUCTOR +casadi__Callback__CONSTRUCTOR__1 :: IO Callback -casadi__Callback__CONSTRUCTOR = +casadi__Callback__CONSTRUCTOR__1 = do errStrPtrP <- new nullPtr - ret <- c_casadi__Callback__CONSTRUCTOR errStrPtrP + ret <- c_casadi__Callback__CONSTRUCTOR__1 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -callback :: IO Callback -callback = casadi__Callback__CONSTRUCTOR +callback__1 :: IO Callback +callback__1 = casadi__Callback__CONSTRUCTOR__1 diff --git a/Casadi/Core/Classes/Callback2.hs b/Casadi/Core/Classes/Callback2.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/Callback2.hs @@ -0,0 +1,266 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.Callback2 + ( + Callback2, + Callback2Class(..), + callback2, + callback2_create, + callback2_inputShape, + callback2_inputSparsity, + callback2_nIn, + callback2_nOut, + callback2_name, + callback2_operator_call, + callback2_options, + callback2_outputShape, + callback2_outputSparsity, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__CONSTRUCTOR" c_casadi__Callback2__CONSTRUCTOR + :: Ptr (Ptr StdString) -> IO (Ptr Callback2') +casadi__Callback2__CONSTRUCTOR + :: IO Callback2 +casadi__Callback2__CONSTRUCTOR = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__CONSTRUCTOR errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2 :: IO Callback2 +callback2 = casadi__Callback2__CONSTRUCTOR + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__create" c_casadi__Callback2__create + :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO (Ptr Function') +casadi__Callback2__create + :: Callback2 -> IO Function +casadi__Callback2__create x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__create errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_create :: Callback2Class a => a -> IO Function +callback2_create x = casadi__Callback2__create (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__inputShape" c_casadi__Callback2__inputShape + :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr (StdPair CInt CInt)) +casadi__Callback2__inputShape + :: Callback2 -> Int -> IO (Int, Int) +casadi__Callback2__inputShape x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__inputShape errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_inputShape :: Callback2Class a => a -> Int -> IO (Int, Int) +callback2_inputShape x = casadi__Callback2__inputShape (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__inputSparsity" c_casadi__Callback2__inputSparsity + :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr Sparsity') +casadi__Callback2__inputSparsity + :: Callback2 -> Int -> IO Sparsity +casadi__Callback2__inputSparsity x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__inputSparsity errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_inputSparsity :: Callback2Class a => a -> Int -> IO Sparsity +callback2_inputSparsity x = casadi__Callback2__inputSparsity (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__nIn" c_casadi__Callback2__nIn + :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO CInt +casadi__Callback2__nIn + :: Callback2 -> IO Int +casadi__Callback2__nIn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__nIn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_nIn :: Callback2Class a => a -> IO Int +callback2_nIn x = casadi__Callback2__nIn (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__nOut" c_casadi__Callback2__nOut + :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO CInt +casadi__Callback2__nOut + :: Callback2 -> IO Int +casadi__Callback2__nOut x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__nOut errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_nOut :: Callback2Class a => a -> IO Int +callback2_nOut x = casadi__Callback2__nOut (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__name" c_casadi__Callback2__name + :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO (Ptr StdString) +casadi__Callback2__name + :: Callback2 -> IO String +casadi__Callback2__name x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__name errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_name :: Callback2Class a => a -> IO String +callback2_name x = casadi__Callback2__name (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__operator_call" c_casadi__Callback2__operator_call + :: Ptr (Ptr StdString) -> Ptr Callback2' -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi__Callback2__operator_call + :: Callback2 -> Vector DMatrix -> IO (Vector DMatrix) +casadi__Callback2__operator_call x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__operator_call errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_operator_call :: Callback2Class a => a -> Vector DMatrix -> IO (Vector DMatrix) +callback2_operator_call x = casadi__Callback2__operator_call (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__options" c_casadi__Callback2__options + :: Ptr (Ptr StdString) -> Ptr Callback2' -> IO (Ptr (StdMap StdString (Ptr GenericType'))) +casadi__Callback2__options + :: Callback2 -> IO (M.Map String GenericType) +casadi__Callback2__options x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__options errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_options :: Callback2Class a => a -> IO (M.Map String GenericType) +callback2_options x = casadi__Callback2__options (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__outputShape" c_casadi__Callback2__outputShape + :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr (StdPair CInt CInt)) +casadi__Callback2__outputShape + :: Callback2 -> Int -> IO (Int, Int) +casadi__Callback2__outputShape x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__outputShape errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_outputShape :: Callback2Class a => a -> Int -> IO (Int, Int) +callback2_outputShape x = casadi__Callback2__outputShape (castCallback2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Callback2__outputSparsity" c_casadi__Callback2__outputSparsity + :: Ptr (Ptr StdString) -> Ptr Callback2' -> CInt -> IO (Ptr Sparsity') +casadi__Callback2__outputSparsity + :: Callback2 -> Int -> IO Sparsity +casadi__Callback2__outputSparsity x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Callback2__outputSparsity errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +callback2_outputSparsity :: Callback2Class a => a -> Int -> IO Sparsity +callback2_outputSparsity x = casadi__Callback2__outputSparsity (castCallback2 x) + diff --git a/Casadi/Core/Classes/CasadiMeta.hs b/Casadi/Core/Classes/CasadiMeta.hs --- a/Casadi/Core/Classes/CasadiMeta.hs +++ b/Casadi/Core/Classes/CasadiMeta.hs @@ -16,6 +16,7 @@ casadiMeta_getFeatureList, casadiMeta_getGitDescribe, casadiMeta_getGitRevision, + casadiMeta_getInstallPrefix, casadiMeta_getModules, casadiMeta_getPlugins, casadiMeta_getVersion, @@ -25,6 +26,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -32,9 +34,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data @@ -177,6 +178,26 @@ -- classy wrapper casadiMeta_getGitRevision :: IO String casadiMeta_getGitRevision = casadi__CasadiMeta__getGitRevision + + +-- direct wrapper +foreign import ccall unsafe "casadi__CasadiMeta__getInstallPrefix" c_casadi__CasadiMeta__getInstallPrefix + :: Ptr (Ptr StdString) -> IO (Ptr StdString) +casadi__CasadiMeta__getInstallPrefix + :: IO String +casadi__CasadiMeta__getInstallPrefix = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CasadiMeta__getInstallPrefix errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +casadiMeta_getInstallPrefix :: IO String +casadiMeta_getInstallPrefix = casadi__CasadiMeta__getInstallPrefix -- direct wrapper diff --git a/Casadi/Core/Classes/CasadiOptions.hs b/Casadi/Core/Classes/CasadiOptions.hs --- a/Casadi/Core/Classes/CasadiOptions.hs +++ b/Casadi/Core/Classes/CasadiOptions.hs @@ -29,6 +29,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -36,9 +37,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data diff --git a/Casadi/Core/Classes/CleSolver.hs b/Casadi/Core/Classes/CleSolver.hs --- a/Casadi/Core/Classes/CleSolver.hs +++ b/Casadi/Core/Classes/CleSolver.hs @@ -9,7 +9,9 @@ ( CleSolver, CleSolverClass(..), - cleSolver, + cleSolver__0, + cleSolver__1, + cleSolver__2, cleSolver_clone, cleSolver_doc, cleSolver_hasPlugin, @@ -21,6 +23,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -28,31 +31,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__CleSolver__CONSTRUCTOR" c_casadi__CleSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__CleSolver__CONSTRUCTOR__0" c_casadi__CleSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr CleSolver') +casadi__CleSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO CleSolver +casadi__CleSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +cleSolver__0 :: String -> String -> M.Map String Sparsity -> IO CleSolver +cleSolver__0 = casadi__CleSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CleSolver__CONSTRUCTOR__1" c_casadi__CleSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CleSolver') +casadi__CleSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO CleSolver +casadi__CleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +cleSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO CleSolver +cleSolver__1 = casadi__CleSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CleSolver__CONSTRUCTOR__2" c_casadi__CleSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr CleSolver') -casadi__CleSolver__CONSTRUCTOR +casadi__CleSolver__CONSTRUCTOR__2 :: IO CleSolver -casadi__CleSolver__CONSTRUCTOR = +casadi__CleSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__CleSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__CleSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -cleSolver :: IO CleSolver -cleSolver = casadi__CleSolver__CONSTRUCTOR +cleSolver__2 :: IO CleSolver +cleSolver__2 = casadi__CleSolver__CONSTRUCTOR__2 -- direct wrapper diff --git a/Casadi/Core/Classes/CodeGenerator.hs b/Casadi/Core/Classes/CodeGenerator.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/CodeGenerator.hs @@ -0,0 +1,274 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.CodeGenerator + ( + CodeGenerator, + CodeGeneratorClass(..), + codeGenerator__0, + codeGenerator__1, + codeGenerator_addInclude__0, + codeGenerator_addInclude__1, + codeGenerator_addInclude__2, + codeGenerator_add__0, + codeGenerator_add__1, + codeGenerator_compile__0, + codeGenerator_compile__1, + codeGenerator_generate__0, + codeGenerator_generate__1, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__CONSTRUCTOR__0" c_casadi__CodeGenerator__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> IO (Ptr CodeGenerator') +casadi__CodeGenerator__CONSTRUCTOR__0 + :: IO CodeGenerator +casadi__CodeGenerator__CONSTRUCTOR__0 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__CONSTRUCTOR__0 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator__0 :: IO CodeGenerator +codeGenerator__0 = casadi__CodeGenerator__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__CONSTRUCTOR__1" c_casadi__CodeGenerator__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CodeGenerator') +casadi__CodeGenerator__CONSTRUCTOR__1 + :: M.Map String GenericType -> IO CodeGenerator +casadi__CodeGenerator__CONSTRUCTOR__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__CONSTRUCTOR__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator__1 :: M.Map String GenericType -> IO CodeGenerator +codeGenerator__1 = casadi__CodeGenerator__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__add__0" c_casadi__CodeGenerator__add__0 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr Function' -> Ptr StdString -> IO () +casadi__CodeGenerator__add__0 + :: CodeGenerator -> Function -> String -> IO () +casadi__CodeGenerator__add__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__add__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_add__0 :: CodeGeneratorClass a => a -> Function -> String -> IO () +codeGenerator_add__0 x = casadi__CodeGenerator__add__0 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__add__1" c_casadi__CodeGenerator__add__1 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr Function' -> IO () +casadi__CodeGenerator__add__1 + :: CodeGenerator -> Function -> IO () +casadi__CodeGenerator__add__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__add__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_add__1 :: CodeGeneratorClass a => a -> Function -> IO () +codeGenerator_add__1 x = casadi__CodeGenerator__add__1 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__addInclude__0" c_casadi__CodeGenerator__addInclude__0 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> IO () +casadi__CodeGenerator__addInclude__0 + :: CodeGenerator -> String -> IO () +casadi__CodeGenerator__addInclude__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__addInclude__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_addInclude__0 :: CodeGeneratorClass a => a -> String -> IO () +codeGenerator_addInclude__0 x = casadi__CodeGenerator__addInclude__0 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__addInclude__1" c_casadi__CodeGenerator__addInclude__1 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> CInt -> IO () +casadi__CodeGenerator__addInclude__1 + :: CodeGenerator -> String -> Bool -> IO () +casadi__CodeGenerator__addInclude__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__addInclude__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_addInclude__1 :: CodeGeneratorClass a => a -> String -> Bool -> IO () +codeGenerator_addInclude__1 x = casadi__CodeGenerator__addInclude__1 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__addInclude__2" c_casadi__CodeGenerator__addInclude__2 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> CInt -> Ptr StdString -> IO () +casadi__CodeGenerator__addInclude__2 + :: CodeGenerator -> String -> Bool -> String -> IO () +casadi__CodeGenerator__addInclude__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__addInclude__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_addInclude__2 :: CodeGeneratorClass a => a -> String -> Bool -> String -> IO () +codeGenerator_addInclude__2 x = casadi__CodeGenerator__addInclude__2 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__compile__0" c_casadi__CodeGenerator__compile__0 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> IO (Ptr StdString) +casadi__CodeGenerator__compile__0 + :: CodeGenerator -> String -> IO String +casadi__CodeGenerator__compile__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__compile__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_compile__0 :: CodeGeneratorClass a => a -> String -> IO String +codeGenerator_compile__0 x = casadi__CodeGenerator__compile__0 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__compile__1" c_casadi__CodeGenerator__compile__1 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> Ptr StdString -> IO (Ptr StdString) +casadi__CodeGenerator__compile__1 + :: CodeGenerator -> String -> String -> IO String +casadi__CodeGenerator__compile__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__compile__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_compile__1 :: CodeGeneratorClass a => a -> String -> String -> IO String +codeGenerator_compile__1 x = casadi__CodeGenerator__compile__1 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__generate__0" c_casadi__CodeGenerator__generate__0 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> IO (Ptr StdString) +casadi__CodeGenerator__generate__0 + :: CodeGenerator -> IO String +casadi__CodeGenerator__generate__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__generate__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_generate__0 :: CodeGeneratorClass a => a -> IO String +codeGenerator_generate__0 x = casadi__CodeGenerator__generate__0 (castCodeGenerator x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__CodeGenerator__generate__1" c_casadi__CodeGenerator__generate__1 + :: Ptr (Ptr StdString) -> Ptr CodeGenerator' -> Ptr StdString -> IO () +casadi__CodeGenerator__generate__1 + :: CodeGenerator -> String -> IO () +casadi__CodeGenerator__generate__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CodeGenerator__generate__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +codeGenerator_generate__1 :: CodeGeneratorClass a => a -> String -> IO () +codeGenerator_generate__1 x = casadi__CodeGenerator__generate__1 (castCodeGenerator x) + diff --git a/Casadi/Core/Classes/Compiler.hs b/Casadi/Core/Classes/Compiler.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/Compiler.hs @@ -0,0 +1,180 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.Compiler + ( + Compiler, + CompilerClass(..), + compiler__0, + compiler__1, + compiler__2, + compiler_doc, + compiler_hasPlugin, + compiler_loadPlugin, + compiler_plugin_name, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__Compiler__CONSTRUCTOR__0" c_casadi__Compiler__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr Compiler') +casadi__Compiler__CONSTRUCTOR__0 + :: String -> String -> IO Compiler +casadi__Compiler__CONSTRUCTOR__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Compiler__CONSTRUCTOR__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +compiler__0 :: String -> String -> IO Compiler +compiler__0 = casadi__Compiler__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Compiler__CONSTRUCTOR__1" c_casadi__Compiler__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Compiler') +casadi__Compiler__CONSTRUCTOR__1 + :: String -> String -> M.Map String GenericType -> IO Compiler +casadi__Compiler__CONSTRUCTOR__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Compiler__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +compiler__1 :: String -> String -> M.Map String GenericType -> IO Compiler +compiler__1 = casadi__Compiler__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Compiler__CONSTRUCTOR__2" c_casadi__Compiler__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> IO (Ptr Compiler') +casadi__Compiler__CONSTRUCTOR__2 + :: IO Compiler +casadi__Compiler__CONSTRUCTOR__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Compiler__CONSTRUCTOR__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +compiler__2 :: IO Compiler +compiler__2 = casadi__Compiler__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Compiler__doc" c_casadi__Compiler__doc + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString) +casadi__Compiler__doc + :: String -> IO String +casadi__Compiler__doc x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Compiler__doc errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +compiler_doc :: String -> IO String +compiler_doc = casadi__Compiler__doc + + +-- direct wrapper +foreign import ccall unsafe "casadi__Compiler__hasPlugin" c_casadi__Compiler__hasPlugin + :: Ptr (Ptr StdString) -> Ptr StdString -> IO CInt +casadi__Compiler__hasPlugin + :: String -> IO Bool +casadi__Compiler__hasPlugin x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Compiler__hasPlugin errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +compiler_hasPlugin :: String -> IO Bool +compiler_hasPlugin = casadi__Compiler__hasPlugin + + +-- direct wrapper +foreign import ccall unsafe "casadi__Compiler__loadPlugin" c_casadi__Compiler__loadPlugin + :: Ptr (Ptr StdString) -> Ptr StdString -> IO () +casadi__Compiler__loadPlugin + :: String -> IO () +casadi__Compiler__loadPlugin x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Compiler__loadPlugin errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +compiler_loadPlugin :: String -> IO () +compiler_loadPlugin = casadi__Compiler__loadPlugin + + +-- direct wrapper +foreign import ccall unsafe "casadi__Compiler__plugin_name" c_casadi__Compiler__plugin_name + :: Ptr (Ptr StdString) -> Ptr Compiler' -> IO (Ptr StdString) +casadi__Compiler__plugin_name + :: Compiler -> IO String +casadi__Compiler__plugin_name x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Compiler__plugin_name errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +compiler_plugin_name :: CompilerClass a => a -> IO String +compiler_plugin_name x = casadi__Compiler__plugin_name (castCompiler x) + diff --git a/Casadi/Core/Classes/ControlSimulator.hs b/Casadi/Core/Classes/ControlSimulator.hs --- a/Casadi/Core/Classes/ControlSimulator.hs +++ b/Casadi/Core/Classes/ControlSimulator.hs @@ -23,6 +23,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -30,96 +31,101 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__0" c_casadi__ControlSimulator__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr ControlSimulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr ControlSimulator') casadi__ControlSimulator__CONSTRUCTOR__0 - :: Function -> DMatrix -> IO ControlSimulator -casadi__ControlSimulator__CONSTRUCTOR__0 x0 x1 = + :: String -> Function -> DMatrix -> IO ControlSimulator +casadi__ControlSimulator__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__ControlSimulator__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__ControlSimulator__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -controlSimulator__0 :: Function -> DMatrix -> IO ControlSimulator +controlSimulator__0 :: String -> Function -> DMatrix -> IO ControlSimulator controlSimulator__0 = casadi__ControlSimulator__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__1" c_casadi__ControlSimulator__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec CDouble) -> IO (Ptr ControlSimulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ControlSimulator') casadi__ControlSimulator__CONSTRUCTOR__1 - :: Function -> Vector Double -> IO ControlSimulator -casadi__ControlSimulator__CONSTRUCTOR__1 x0 x1 = + :: String -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator +casadi__ControlSimulator__CONSTRUCTOR__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__ControlSimulator__CONSTRUCTOR__1 errStrPtrP x0' x1' + ret <- c_casadi__ControlSimulator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -controlSimulator__1 :: Function -> Vector Double -> IO ControlSimulator +controlSimulator__1 :: String -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator controlSimulator__1 = casadi__ControlSimulator__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__2" c_casadi__ControlSimulator__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr ControlSimulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr ControlSimulator') casadi__ControlSimulator__CONSTRUCTOR__2 - :: Function -> Function -> DMatrix -> IO ControlSimulator -casadi__ControlSimulator__CONSTRUCTOR__2 x0 x1 x2 = + :: String -> Function -> Function -> DMatrix -> IO ControlSimulator +casadi__ControlSimulator__CONSTRUCTOR__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__ControlSimulator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' + ret <- c_casadi__ControlSimulator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -controlSimulator__2 :: Function -> Function -> DMatrix -> IO ControlSimulator +controlSimulator__2 :: String -> Function -> Function -> DMatrix -> IO ControlSimulator controlSimulator__2 = casadi__ControlSimulator__CONSTRUCTOR__2 -- direct wrapper foreign import ccall unsafe "casadi__ControlSimulator__CONSTRUCTOR__3" c_casadi__ControlSimulator__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> Ptr (StdVec CDouble) -> IO (Ptr ControlSimulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ControlSimulator') casadi__ControlSimulator__CONSTRUCTOR__3 - :: Function -> Function -> Vector Double -> IO ControlSimulator -casadi__ControlSimulator__CONSTRUCTOR__3 x0 x1 x2 = + :: String -> Function -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator +casadi__ControlSimulator__CONSTRUCTOR__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__ControlSimulator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' + ret <- c_casadi__ControlSimulator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -controlSimulator__3 :: Function -> Function -> Vector Double -> IO ControlSimulator +controlSimulator__3 :: String -> Function -> Function -> DMatrix -> M.Map String GenericType -> IO ControlSimulator controlSimulator__3 = casadi__ControlSimulator__CONSTRUCTOR__3 diff --git a/Casadi/Core/Classes/CustomEvaluate.hs b/Casadi/Core/Classes/CustomEvaluate.hs --- a/Casadi/Core/Classes/CustomEvaluate.hs +++ b/Casadi/Core/Classes/CustomEvaluate.hs @@ -16,6 +16,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -23,9 +24,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data diff --git a/Casadi/Core/Classes/CustomFunction.hs b/Casadi/Core/Classes/CustomFunction.hs --- a/Casadi/Core/Classes/CustomFunction.hs +++ b/Casadi/Core/Classes/CustomFunction.hs @@ -12,12 +12,19 @@ customFunction__0, customFunction__1, customFunction__2, + customFunction__3, + customFunction__4, + customFunction__5, + customFunction__6, + customFunction__7, + customFunction__8, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -25,71 +32,216 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__0" c_casadi__CustomFunction__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr CustomEvaluate' -> IO (Ptr CustomFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr CustomFunction') casadi__CustomFunction__CONSTRUCTOR__0 - :: CustomEvaluate -> IO CustomFunction -casadi__CustomFunction__CONSTRUCTOR__0 x0 = + :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__CustomFunction__CONSTRUCTOR__0 errStrPtrP x0' + ret <- c_casadi__CustomFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -customFunction__0 :: CustomEvaluate -> IO CustomFunction +customFunction__0 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> IO CustomFunction customFunction__0 = casadi__CustomFunction__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__1" c_casadi__CustomFunction__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr CustomFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction') casadi__CustomFunction__CONSTRUCTOR__1 - :: CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> IO CustomFunction -casadi__CustomFunction__CONSTRUCTOR__1 x0 x1 x2 = + :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__1 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__CustomFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' + ret <- c_casadi__CustomFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -customFunction__1 :: CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> IO CustomFunction +customFunction__1 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction customFunction__1 = casadi__CustomFunction__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__2" c_casadi__CustomFunction__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> IO (Ptr CustomFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr CustomFunction') casadi__CustomFunction__CONSTRUCTOR__2 + :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CustomFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +customFunction__2 :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> IO CustomFunction +customFunction__2 = casadi__CustomFunction__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__3" c_casadi__CustomFunction__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction') +casadi__CustomFunction__CONSTRUCTOR__3 + :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CustomFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +customFunction__3 :: String -> CustomEvaluate -> Vector Sparsity -> (M.Map String Sparsity, Vector String) -> M.Map String GenericType -> IO CustomFunction +customFunction__3 = casadi__CustomFunction__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__4" c_casadi__CustomFunction__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr CustomFunction') +casadi__CustomFunction__CONSTRUCTOR__4 + :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CustomFunction__CONSTRUCTOR__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +customFunction__4 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> IO CustomFunction +customFunction__4 = casadi__CustomFunction__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__5" c_casadi__CustomFunction__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction') +casadi__CustomFunction__CONSTRUCTOR__5 + :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__5 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CustomFunction__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +customFunction__5 :: String -> CustomEvaluate -> (M.Map String Sparsity, Vector String) -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction +customFunction__5 = casadi__CustomFunction__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__6" c_casadi__CustomFunction__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr CustomFunction') +casadi__CustomFunction__CONSTRUCTOR__6 + :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CustomFunction__CONSTRUCTOR__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +customFunction__6 :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> IO CustomFunction +customFunction__6 = casadi__CustomFunction__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__7" c_casadi__CustomFunction__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr CustomEvaluate' -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr CustomFunction') +casadi__CustomFunction__CONSTRUCTOR__7 + :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction +casadi__CustomFunction__CONSTRUCTOR__7 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__CustomFunction__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +customFunction__7 :: String -> CustomEvaluate -> Vector Sparsity -> Vector Sparsity -> M.Map String GenericType -> IO CustomFunction +customFunction__7 = casadi__CustomFunction__CONSTRUCTOR__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__8" c_casadi__CustomFunction__CONSTRUCTOR__8 + :: Ptr (Ptr StdString) -> IO (Ptr CustomFunction') +casadi__CustomFunction__CONSTRUCTOR__8 :: IO CustomFunction -casadi__CustomFunction__CONSTRUCTOR__2 = +casadi__CustomFunction__CONSTRUCTOR__8 = do errStrPtrP <- new nullPtr - ret <- c_casadi__CustomFunction__CONSTRUCTOR__2 errStrPtrP + ret <- c_casadi__CustomFunction__CONSTRUCTOR__8 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -customFunction__2 :: IO CustomFunction -customFunction__2 = casadi__CustomFunction__CONSTRUCTOR__2 +customFunction__8 :: IO CustomFunction +customFunction__8 = casadi__CustomFunction__CONSTRUCTOR__8 diff --git a/Casadi/Core/Classes/DMatrix.hs b/Casadi/Core/Classes/DMatrix.hs --- a/Casadi/Core/Classes/DMatrix.hs +++ b/Casadi/Core/Classes/DMatrix.hs @@ -19,7222 +19,3917 @@ dmatrix__6, dmatrix__7, dmatrix__8, - dmatrix___constpow__, - dmatrix___copysign__, - dmatrix___mldivide__, - dmatrix___mrdivide__, - dmatrix___nonzero__, - dmatrix___truediv____0, - dmatrix___truediv____1, - dmatrix_append, - dmatrix_appendColumns, - dmatrix_binary, - dmatrix_className, - dmatrix_clear, - dmatrix_colind, - dmatrix_dimString, - dmatrix_enlarge__0, - dmatrix_enlarge__1, - dmatrix_erase__0, - dmatrix_erase__1, - dmatrix_erase__2, - dmatrix_erase__3, - dmatrix_eye, - dmatrix_find__0, - dmatrix_find__1, - dmatrix_getColind, - dmatrix_getDep__0, - dmatrix_getDep__1, - dmatrix_getDescription, - dmatrix_getElementHash, - dmatrix_getEqualityCheckingDepth, - dmatrix_getIntValue, - dmatrix_getMaxNumCallsInPrint, - dmatrix_getNZ__0, - dmatrix_getNZ__1, - dmatrix_getNZ__2, - dmatrix_getName, - dmatrix_getNdeps, - dmatrix_getRepresentation, - dmatrix_getRow, - dmatrix_getSparsity, - dmatrix_getSym, - dmatrix_getValue__0, - dmatrix_getValue__1, - dmatrix_get__0, - dmatrix_get__1, - dmatrix_get__2, - dmatrix_get__3, - dmatrix_get__4, - dmatrix_get__5, - dmatrix_get__6, - dmatrix_get__7, - dmatrix_hasNZ, - dmatrix_hasNonStructuralZeros, - dmatrix_inf__0, - dmatrix_inf__1, - dmatrix_inf__2, - dmatrix_inf__3, - dmatrix_isCommutative, - dmatrix_isConstant, - dmatrix_isDense, - dmatrix_isEmpty__0, - dmatrix_isEmpty__1, - dmatrix_isIdentity, - dmatrix_isInteger, - dmatrix_isLeaf, - dmatrix_isMinusOne, - dmatrix_isOne, - dmatrix_isRegular, - dmatrix_isRowVector, - dmatrix_isScalar__0, - dmatrix_isScalar__1, - dmatrix_isSlice__0, - dmatrix_isSlice__1, - dmatrix_isSmooth, - dmatrix_isSquare, - dmatrix_isSymbolic, - dmatrix_isSymbolicSparse, - dmatrix_isTril, - dmatrix_isTriu, - dmatrix_isVector__0, - dmatrix_isVector__1, - dmatrix_isZero, - dmatrix_makeSparse__0, - dmatrix_makeSparse__1, - dmatrix_matrix_matrix, - dmatrix_matrix_scalar, - dmatrix_nan__0, - dmatrix_nan__1, - dmatrix_nan__2, - dmatrix_nan__3, - dmatrix_nnz, - dmatrix_nonzeros, - dmatrix_nonzeros_int, - dmatrix_numel__0, - dmatrix_numel__1, - dmatrix_ones__0, - dmatrix_ones__1, - dmatrix_ones__2, - dmatrix_ones__3, - dmatrix_operator_minus, - dmatrix_operator_plus, - dmatrix_printDense, - dmatrix_printScalar, - dmatrix_printSparse, - dmatrix_printVector, - dmatrix_printme, - dmatrix_remove, - dmatrix_reserve__0, - dmatrix_reserve__1, - dmatrix_resize, - dmatrix_row, - dmatrix_sanityCheck__0, - dmatrix_sanityCheck__1, - dmatrix_scalar_matrix, - dmatrix_setEqualityCheckingDepth__0, - dmatrix_setEqualityCheckingDepth__1, - dmatrix_setMaxNumCallsInPrint__0, - dmatrix_setMaxNumCallsInPrint__1, - dmatrix_setNZ__0, - dmatrix_setNZ__1, - dmatrix_setNZ__2, - dmatrix_setNZ__3, - dmatrix_setPrecision, - dmatrix_setScientific, - dmatrix_setSparse__0, - dmatrix_setSparse__1, - dmatrix_setSym, - dmatrix_setValue__0, - dmatrix_setValue__1, - dmatrix_setWidth, - dmatrix_setZero, - dmatrix_set__0, - dmatrix_set__1, - dmatrix_set__10, - dmatrix_set__2, - dmatrix_set__3, - dmatrix_set__4, - dmatrix_set__5, - dmatrix_set__6, - dmatrix_set__7, - dmatrix_set__8, - dmatrix_set__9, - dmatrix_size1, - dmatrix_size2, - dmatrix_sizeD, - dmatrix_sizeL, - dmatrix_sizeU, - dmatrix_size__0, - dmatrix_size__1, - dmatrix_sparse__0, - dmatrix_sparse__1, - dmatrix_sparse__2, - dmatrix_sparse__3, - dmatrix_sparsity, - dmatrix_sparsityRef, - dmatrix_sym__0, - dmatrix_sym__1, - dmatrix_sym__2, - dmatrix_sym__3, - dmatrix_sym__4, - dmatrix_sym__5, - dmatrix_sym__6, - dmatrix_sym__7, - dmatrix_toSlice__0, - dmatrix_toSlice__1, - dmatrix_triplet__0, - dmatrix_triplet__1, - dmatrix_unary, - dmatrix_zeros__0, - dmatrix_zeros__1, - dmatrix_zeros__2, - dmatrix_zeros__3, - dmatrix_zz_abs, - dmatrix_zz_acos, - dmatrix_zz_acosh, - dmatrix_zz_adj, - dmatrix_zz_all, - dmatrix_zz_and, - dmatrix_zz_any, - dmatrix_zz_asin, - dmatrix_zz_asinh, - dmatrix_zz_atan, - dmatrix_zz_atan2, - dmatrix_zz_atanh, - dmatrix_zz_blockcat, - dmatrix_zz_blocksplit, - dmatrix_zz_ceil, - dmatrix_zz_cofactor, - dmatrix_zz_cos, - dmatrix_zz_cosh, - dmatrix_zz_countNodes, - dmatrix_zz_cross__0, - dmatrix_zz_cross__1, - dmatrix_zz_densify, - dmatrix_zz_dependsOn, - dmatrix_zz_det, - dmatrix_zz_diag, - dmatrix_zz_diagcat, - dmatrix_zz_diagsplit, - dmatrix_zz_eig_symbolic, - dmatrix_zz_eq, - dmatrix_zz_erf, - dmatrix_zz_erfinv, - dmatrix_zz_exp, - dmatrix_zz_expand, - dmatrix_zz_extractShared__0, - dmatrix_zz_extractShared__1, - dmatrix_zz_extractShared__2, - dmatrix_zz_floor, - dmatrix_zz_gauss_quadrature__0, - dmatrix_zz_gauss_quadrature__1, - dmatrix_zz_gauss_quadrature__2, - dmatrix_zz_ge, - dmatrix_zz_getMinor, - dmatrix_zz_getOperatorRepresentation, - dmatrix_zz_getSymbols__0, - dmatrix_zz_getSymbols__1, - dmatrix_zz_gradient, - dmatrix_zz_gt, - dmatrix_zz_heaviside, - dmatrix_zz_hessian__0, - dmatrix_zz_hessian__1, - dmatrix_zz_horzcat, - dmatrix_zz_horzsplit, - dmatrix_zz_if_else, - dmatrix_zz_if_else_zero, - dmatrix_zz_inner_prod, - dmatrix_zz_inv, - dmatrix_zz_isEqual__0, - dmatrix_zz_isEqual__1, - dmatrix_zz_jacobian, - dmatrix_zz_jacobianTimesVector__0, - dmatrix_zz_jacobianTimesVector__1, - dmatrix_zz_kron, - dmatrix_zz_le, - dmatrix_zz_linspace, - dmatrix_zz_log, - dmatrix_zz_log10, - dmatrix_zz_lt, - dmatrix_zz_max, - dmatrix_zz_min, - dmatrix_zz_minus, - dmatrix_zz_mod, - dmatrix_zz_mpower, - dmatrix_zz_mtaylor__0, - dmatrix_zz_mtaylor__1, - dmatrix_zz_mtaylor__2, - dmatrix_zz_mtimes__0, - dmatrix_zz_mtimes__1, - dmatrix_zz_ne, - dmatrix_zz_norm_0_mul, - dmatrix_zz_norm_1, - dmatrix_zz_norm_2, - dmatrix_zz_norm_F, - dmatrix_zz_norm_inf, - dmatrix_zz_norm_inf_mul, - dmatrix_zz_not, - dmatrix_zz_nullspace, - dmatrix_zz_or, - dmatrix_zz_outer_prod, - dmatrix_zz_pinv, - dmatrix_zz_plus, - dmatrix_zz_poly_coeff, - dmatrix_zz_poly_roots, - dmatrix_zz_polyval, - dmatrix_zz_power, - dmatrix_zz_printCompact, - dmatrix_zz_project, - dmatrix_zz_pw_const, - dmatrix_zz_pw_lin, - dmatrix_zz_qr, - dmatrix_zz_quad_form__0, - dmatrix_zz_quad_form__1, - dmatrix_zz_quad_form__2, - dmatrix_zz_quad_form__3, - dmatrix_zz_ramp, - dmatrix_zz_rdivide, - dmatrix_zz_rectangle, - dmatrix_zz_repmat__0, - dmatrix_zz_repmat__1, - dmatrix_zz_reshape__0, - dmatrix_zz_reshape__1, - dmatrix_zz_sign, - dmatrix_zz_simplify, - dmatrix_zz_sin, - dmatrix_zz_sinh, - dmatrix_zz_solve, - dmatrix_zz_sparsify__0, - dmatrix_zz_sparsify__1, - dmatrix_zz_sprank, - dmatrix_zz_spy, - dmatrix_zz_sqrt, - dmatrix_zz_substituteInPlace__0, - dmatrix_zz_substituteInPlace__1, - dmatrix_zz_substitute__0, - dmatrix_zz_substitute__1, - dmatrix_zz_sumAll, - dmatrix_zz_sumCols, - dmatrix_zz_sumRows, - dmatrix_zz_sum_square, - dmatrix_zz_tan, - dmatrix_zz_tangent, - dmatrix_zz_tanh, - dmatrix_zz_taylor__0, - dmatrix_zz_taylor__1, - dmatrix_zz_taylor__2, - dmatrix_zz_times, - dmatrix_zz_trace, - dmatrix_zz_triangle, - dmatrix_zz_tril2symm, - dmatrix_zz_tril__0, - dmatrix_zz_tril__1, - dmatrix_zz_triu2symm, - dmatrix_zz_triu__0, - dmatrix_zz_triu__1, - dmatrix_zz_unite, - dmatrix_zz_vec, - dmatrix_zz_vecNZ, - dmatrix_zz_vecNZcat, - dmatrix_zz_veccat, - dmatrix_zz_vertcat, - dmatrix_zz_vertsplit, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__0" c_casadi__DMatrix__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__0 - :: Vector Int -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__0 :: Vector Int -> IO DMatrix -dmatrix__0 = casadi__DMatrix__CONSTRUCTOR__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__1" c_casadi__DMatrix__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__1 - :: IMatrix -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__1 :: IMatrix -> IO DMatrix -dmatrix__1 = casadi__DMatrix__CONSTRUCTOR__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__2" c_casadi__DMatrix__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__2 - :: Vector (Vector Double) -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__2 :: Vector (Vector Double) -> IO DMatrix -dmatrix__2 = casadi__DMatrix__CONSTRUCTOR__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__3" c_casadi__DMatrix__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__3 - :: Double -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__3 :: Double -> IO DMatrix -dmatrix__3 = casadi__DMatrix__CONSTRUCTOR__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__4" c_casadi__DMatrix__CONSTRUCTOR__4 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__4 - :: Sparsity -> DMatrix -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__4 :: Sparsity -> DMatrix -> IO DMatrix -dmatrix__4 = casadi__DMatrix__CONSTRUCTOR__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__5" c_casadi__DMatrix__CONSTRUCTOR__5 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__5 - :: Sparsity -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__5 :: Sparsity -> IO DMatrix -dmatrix__5 = casadi__DMatrix__CONSTRUCTOR__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__6" c_casadi__DMatrix__CONSTRUCTOR__6 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__6 - :: Int -> Int -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__6 :: Int -> Int -> IO DMatrix -dmatrix__6 = casadi__DMatrix__CONSTRUCTOR__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__7" c_casadi__DMatrix__CONSTRUCTOR__7 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__7 - :: DMatrix -> IO DMatrix -casadi__DMatrix__CONSTRUCTOR__7 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__7 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__7 :: DMatrix -> IO DMatrix -dmatrix__7 = casadi__DMatrix__CONSTRUCTOR__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__8" c_casadi__DMatrix__CONSTRUCTOR__8 - :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') -casadi__DMatrix__CONSTRUCTOR__8 - :: IO DMatrix -casadi__DMatrix__CONSTRUCTOR__8 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__CONSTRUCTOR__8 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix__8 :: IO DMatrix -dmatrix__8 = casadi__DMatrix__CONSTRUCTOR__8 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__T" c_casadi__DMatrix__T - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__T - :: DMatrix -> IO DMatrix -casadi__DMatrix__T x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__T errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_T :: DMatrixClass a => a -> IO DMatrix -dmatrix_T x = casadi__DMatrix__T (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix____constpow__" c_casadi__DMatrix____constpow__ - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix____constpow__ - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix____constpow__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix____constpow__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix___constpow__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix___constpow__ x = casadi__DMatrix____constpow__ (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix____copysign__" c_casadi__DMatrix____copysign__ - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix____copysign__ - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix____copysign__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix____copysign__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix___copysign__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix___copysign__ x = casadi__DMatrix____copysign__ (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix____mldivide__" c_casadi__DMatrix____mldivide__ - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix____mldivide__ - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix____mldivide__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix____mldivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix___mldivide__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix___mldivide__ x = casadi__DMatrix____mldivide__ (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix____mrdivide__" c_casadi__DMatrix____mrdivide__ - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix____mrdivide__ - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix____mrdivide__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix____mrdivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix___mrdivide__ :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix___mrdivide__ x = casadi__DMatrix____mrdivide__ (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix____nonzero__" c_casadi__DMatrix____nonzero__ - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix____nonzero__ - :: DMatrix -> IO Bool -casadi__DMatrix____nonzero__ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix____nonzero__ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix___nonzero__ :: DMatrixClass a => a -> IO Bool -dmatrix___nonzero__ x = casadi__DMatrix____nonzero__ (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix____truediv____0" c_casadi__DMatrix____truediv____0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix____truediv____0 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix____truediv____0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix____truediv____0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix___truediv____0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix___truediv____0 x = casadi__DMatrix____truediv____0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix____truediv____1" c_casadi__DMatrix____truediv____1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix____truediv____1 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix____truediv____1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix____truediv____1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix___truediv____1 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix___truediv____1 x = casadi__DMatrix____truediv____1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__append" c_casadi__DMatrix__append - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO () -casadi__DMatrix__append - :: DMatrix -> DMatrix -> IO () -casadi__DMatrix__append x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__append errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_append :: DMatrixClass a => a -> DMatrix -> IO () -dmatrix_append x = casadi__DMatrix__append (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__appendColumns" c_casadi__DMatrix__appendColumns - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO () -casadi__DMatrix__appendColumns - :: DMatrix -> DMatrix -> IO () -casadi__DMatrix__appendColumns x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__appendColumns errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_appendColumns :: DMatrixClass a => a -> DMatrix -> IO () -dmatrix_appendColumns x = casadi__DMatrix__appendColumns (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__binary" c_casadi__DMatrix__binary - :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__binary - :: Int -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__binary x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__binary errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_binary :: Int -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_binary = casadi__DMatrix__binary - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__className" c_casadi__DMatrix__className - :: Ptr (Ptr StdString) -> IO (Ptr StdString) -casadi__DMatrix__className - :: IO String -casadi__DMatrix__className = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__className errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_className :: IO String -dmatrix_className = casadi__DMatrix__className - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__clear" c_casadi__DMatrix__clear - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__clear - :: DMatrix -> IO () -casadi__DMatrix__clear x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__clear errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_clear :: DMatrixClass a => a -> IO () -dmatrix_clear x = casadi__DMatrix__clear (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__colind" c_casadi__DMatrix__colind - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__colind - :: DMatrix -> Int -> IO Int -casadi__DMatrix__colind x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__colind errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_colind :: DMatrixClass a => a -> Int -> IO Int -dmatrix_colind x = casadi__DMatrix__colind (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__dimString" c_casadi__DMatrix__dimString - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString) -casadi__DMatrix__dimString - :: DMatrix -> IO String -casadi__DMatrix__dimString x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__dimString errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_dimString :: DMatrixClass a => a -> IO String -dmatrix_dimString x = casadi__DMatrix__dimString (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__enlarge__0" c_casadi__DMatrix__enlarge__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__DMatrix__enlarge__0 - :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () -casadi__DMatrix__enlarge__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_enlarge__0 :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () -dmatrix_enlarge__0 x = casadi__DMatrix__enlarge__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__enlarge__1" c_casadi__DMatrix__enlarge__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__DMatrix__enlarge__1 - :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -casadi__DMatrix__enlarge__1 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_enlarge__1 :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -dmatrix_enlarge__1 x = casadi__DMatrix__enlarge__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__erase__0" c_casadi__DMatrix__erase__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO () -casadi__DMatrix__erase__0 - :: DMatrix -> Vector Int -> IO () -casadi__DMatrix__erase__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__erase__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_erase__0 :: DMatrixClass a => a -> Vector Int -> IO () -dmatrix_erase__0 x = casadi__DMatrix__erase__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__erase__1" c_casadi__DMatrix__erase__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__DMatrix__erase__1 - :: DMatrix -> Vector Int -> Bool -> IO () -casadi__DMatrix__erase__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__erase__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_erase__1 :: DMatrixClass a => a -> Vector Int -> Bool -> IO () -dmatrix_erase__1 x = casadi__DMatrix__erase__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__erase__2" c_casadi__DMatrix__erase__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__DMatrix__erase__2 - :: DMatrix -> Vector Int -> Vector Int -> IO () -casadi__DMatrix__erase__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__erase__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_erase__2 :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO () -dmatrix_erase__2 x = casadi__DMatrix__erase__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__erase__3" c_casadi__DMatrix__erase__3 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__DMatrix__erase__3 - :: DMatrix -> Vector Int -> Vector Int -> Bool -> IO () -casadi__DMatrix__erase__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__erase__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_erase__3 :: DMatrixClass a => a -> Vector Int -> Vector Int -> Bool -> IO () -dmatrix_erase__3 x = casadi__DMatrix__erase__3 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__eye" c_casadi__DMatrix__eye - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__eye - :: Int -> IO DMatrix -casadi__DMatrix__eye x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__eye errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_eye :: Int -> IO DMatrix -dmatrix_eye = casadi__DMatrix__eye - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__find__0" c_casadi__DMatrix__find__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) -casadi__DMatrix__find__0 - :: DMatrix -> IO (Vector Int) -casadi__DMatrix__find__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__find__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_find__0 :: DMatrixClass a => a -> IO (Vector Int) -dmatrix_find__0 x = casadi__DMatrix__find__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__find__1" c_casadi__DMatrix__find__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec CInt)) -casadi__DMatrix__find__1 - :: DMatrix -> Bool -> IO (Vector Int) -casadi__DMatrix__find__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__find__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_find__1 :: DMatrixClass a => a -> Bool -> IO (Vector Int) -dmatrix_find__1 x = casadi__DMatrix__find__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__0" c_casadi__DMatrix__get__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__DMatrix__get__0 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () -casadi__DMatrix__get__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () -dmatrix_get__0 x = casadi__DMatrix__get__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__1" c_casadi__DMatrix__get__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__DMatrix__get__1 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> Slice -> IO () -casadi__DMatrix__get__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__1 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> Slice -> IO () -dmatrix_get__1 x = casadi__DMatrix__get__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__2" c_casadi__DMatrix__get__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__DMatrix__get__2 - :: DMatrix -> DMatrix -> Bool -> Slice -> IMatrix -> IO () -casadi__DMatrix__get__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__2 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IMatrix -> IO () -dmatrix_get__2 x = casadi__DMatrix__get__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__3" c_casadi__DMatrix__get__3 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__DMatrix__get__3 - :: DMatrix -> DMatrix -> Bool -> Slice -> Slice -> IO () -casadi__DMatrix__get__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__3 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> Slice -> IO () -dmatrix_get__3 x = casadi__DMatrix__get__3 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__4" c_casadi__DMatrix__get__4 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Sparsity' -> IO () -casadi__DMatrix__get__4 - :: DMatrix -> DMatrix -> Bool -> Sparsity -> IO () -casadi__DMatrix__get__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__4 :: DMatrixClass a => a -> DMatrix -> Bool -> Sparsity -> IO () -dmatrix_get__4 x = casadi__DMatrix__get__4 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__5" c_casadi__DMatrix__get__5 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__DMatrix__get__5 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () -casadi__DMatrix__get__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__5 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () -dmatrix_get__5 x = casadi__DMatrix__get__5 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__6" c_casadi__DMatrix__get__6 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__DMatrix__get__6 - :: DMatrix -> DMatrix -> Bool -> Slice -> IO () -casadi__DMatrix__get__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__6 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () -dmatrix_get__6 x = casadi__DMatrix__get__6 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__get__7" c_casadi__DMatrix__get__7 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__DMatrix__get__7 - :: DMatrix -> Vector Double -> IO () -casadi__DMatrix__get__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__get__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_get__7 :: DMatrixClass a => a -> Vector Double -> IO () -dmatrix_get__7 x = casadi__DMatrix__get__7 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getColind" c_casadi__DMatrix__getColind - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) -casadi__DMatrix__getColind - :: DMatrix -> IO (Vector Int) -casadi__DMatrix__getColind x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getColind errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getColind :: DMatrixClass a => a -> IO (Vector Int) -dmatrix_getColind x = casadi__DMatrix__getColind (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getDep__0" c_casadi__DMatrix__getDep__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__getDep__0 - :: DMatrix -> IO DMatrix -casadi__DMatrix__getDep__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getDep__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getDep__0 :: DMatrixClass a => a -> IO DMatrix -dmatrix_getDep__0 x = casadi__DMatrix__getDep__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getDep__1" c_casadi__DMatrix__getDep__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__getDep__1 - :: DMatrix -> Int -> IO DMatrix -casadi__DMatrix__getDep__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getDep__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getDep__1 :: DMatrixClass a => a -> Int -> IO DMatrix -dmatrix_getDep__1 x = casadi__DMatrix__getDep__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getElementHash" c_casadi__DMatrix__getElementHash - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CLong -casadi__DMatrix__getElementHash - :: DMatrix -> IO Int -casadi__DMatrix__getElementHash x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getElementHash errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getElementHash :: DMatrixClass a => a -> IO Int -dmatrix_getElementHash x = casadi__DMatrix__getElementHash (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getEqualityCheckingDepth" c_casadi__DMatrix__getEqualityCheckingDepth - :: Ptr (Ptr StdString) -> IO CInt -casadi__DMatrix__getEqualityCheckingDepth - :: IO Int -casadi__DMatrix__getEqualityCheckingDepth = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getEqualityCheckingDepth errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getEqualityCheckingDepth :: IO Int -dmatrix_getEqualityCheckingDepth = casadi__DMatrix__getEqualityCheckingDepth - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getIntValue" c_casadi__DMatrix__getIntValue - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__getIntValue - :: DMatrix -> IO Int -casadi__DMatrix__getIntValue x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getIntValue errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getIntValue :: DMatrixClass a => a -> IO Int -dmatrix_getIntValue x = casadi__DMatrix__getIntValue (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getMaxNumCallsInPrint" c_casadi__DMatrix__getMaxNumCallsInPrint - :: Ptr (Ptr StdString) -> IO CLong -casadi__DMatrix__getMaxNumCallsInPrint - :: IO Int -casadi__DMatrix__getMaxNumCallsInPrint = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getMaxNumCallsInPrint errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getMaxNumCallsInPrint :: IO Int -dmatrix_getMaxNumCallsInPrint = casadi__DMatrix__getMaxNumCallsInPrint - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getNZ__0" c_casadi__DMatrix__getNZ__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__DMatrix__getNZ__0 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () -casadi__DMatrix__getNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getNZ__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () -dmatrix_getNZ__0 x = casadi__DMatrix__getNZ__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getNZ__1" c_casadi__DMatrix__getNZ__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__DMatrix__getNZ__1 - :: DMatrix -> DMatrix -> Bool -> Slice -> IO () -casadi__DMatrix__getNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getNZ__1 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () -dmatrix_getNZ__1 x = casadi__DMatrix__getNZ__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getNZ__2" c_casadi__DMatrix__getNZ__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__DMatrix__getNZ__2 - :: DMatrix -> Vector Double -> IO () -casadi__DMatrix__getNZ__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getNZ__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getNZ__2 :: DMatrixClass a => a -> Vector Double -> IO () -dmatrix_getNZ__2 x = casadi__DMatrix__getNZ__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getName" c_casadi__DMatrix__getName - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString) -casadi__DMatrix__getName - :: DMatrix -> IO String -casadi__DMatrix__getName x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getName errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getName :: DMatrixClass a => a -> IO String -dmatrix_getName x = casadi__DMatrix__getName (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getNdeps" c_casadi__DMatrix__getNdeps - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__getNdeps - :: DMatrix -> IO Int -casadi__DMatrix__getNdeps x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getNdeps errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getNdeps :: DMatrixClass a => a -> IO Int -dmatrix_getNdeps x = casadi__DMatrix__getNdeps (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getRow" c_casadi__DMatrix__getRow - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) -casadi__DMatrix__getRow - :: DMatrix -> IO (Vector Int) -casadi__DMatrix__getRow x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getRow errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getRow :: DMatrixClass a => a -> IO (Vector Int) -dmatrix_getRow x = casadi__DMatrix__getRow (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getSparsity" c_casadi__DMatrix__getSparsity - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Sparsity') -casadi__DMatrix__getSparsity - :: DMatrix -> IO Sparsity -casadi__DMatrix__getSparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getSparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getSparsity :: DMatrixClass a => a -> IO Sparsity -dmatrix_getSparsity x = casadi__DMatrix__getSparsity (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getSym" c_casadi__DMatrix__getSym - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__DMatrix__getSym - :: DMatrix -> Vector Double -> IO () -casadi__DMatrix__getSym x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getSym errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getSym :: DMatrixClass a => a -> Vector Double -> IO () -dmatrix_getSym x = casadi__DMatrix__getSym (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getValue__0" c_casadi__DMatrix__getValue__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CDouble -casadi__DMatrix__getValue__0 - :: DMatrix -> Int -> IO Double -casadi__DMatrix__getValue__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getValue__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getValue__0 :: DMatrixClass a => a -> Int -> IO Double -dmatrix_getValue__0 x = casadi__DMatrix__getValue__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__getValue__1" c_casadi__DMatrix__getValue__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CDouble -casadi__DMatrix__getValue__1 - :: DMatrix -> IO Double -casadi__DMatrix__getValue__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__getValue__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_getValue__1 :: DMatrixClass a => a -> IO Double -dmatrix_getValue__1 x = casadi__DMatrix__getValue__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__hasNZ" c_casadi__DMatrix__hasNZ - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO CInt -casadi__DMatrix__hasNZ - :: DMatrix -> Int -> Int -> IO Bool -casadi__DMatrix__hasNZ x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__hasNZ errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_hasNZ :: DMatrixClass a => a -> Int -> Int -> IO Bool -dmatrix_hasNZ x = casadi__DMatrix__hasNZ (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__hasNonStructuralZeros" c_casadi__DMatrix__hasNonStructuralZeros - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__hasNonStructuralZeros - :: DMatrix -> IO Bool -casadi__DMatrix__hasNonStructuralZeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__hasNonStructuralZeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_hasNonStructuralZeros :: DMatrixClass a => a -> IO Bool -dmatrix_hasNonStructuralZeros x = casadi__DMatrix__hasNonStructuralZeros (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__inf__0" c_casadi__DMatrix__inf__0 - :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') -casadi__DMatrix__inf__0 - :: IO DMatrix -casadi__DMatrix__inf__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__inf__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_inf__0 :: IO DMatrix -dmatrix_inf__0 = casadi__DMatrix__inf__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__inf__1" c_casadi__DMatrix__inf__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__inf__1 - :: Int -> IO DMatrix -casadi__DMatrix__inf__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__inf__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_inf__1 :: Int -> IO DMatrix -dmatrix_inf__1 = casadi__DMatrix__inf__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__inf__2" c_casadi__DMatrix__inf__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__inf__2 - :: Int -> Int -> IO DMatrix -casadi__DMatrix__inf__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__inf__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_inf__2 :: Int -> Int -> IO DMatrix -dmatrix_inf__2 = casadi__DMatrix__inf__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__inf__3" c_casadi__DMatrix__inf__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__inf__3 - :: Sparsity -> IO DMatrix -casadi__DMatrix__inf__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__inf__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_inf__3 :: Sparsity -> IO DMatrix -dmatrix_inf__3 = casadi__DMatrix__inf__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isCommutative" c_casadi__DMatrix__isCommutative - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isCommutative - :: DMatrix -> IO Bool -casadi__DMatrix__isCommutative x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isCommutative errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isCommutative :: DMatrixClass a => a -> IO Bool -dmatrix_isCommutative x = casadi__DMatrix__isCommutative (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isConstant" c_casadi__DMatrix__isConstant - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isConstant - :: DMatrix -> IO Bool -casadi__DMatrix__isConstant x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isConstant errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isConstant :: DMatrixClass a => a -> IO Bool -dmatrix_isConstant x = casadi__DMatrix__isConstant (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isDense" c_casadi__DMatrix__isDense - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isDense - :: DMatrix -> IO Bool -casadi__DMatrix__isDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isDense :: DMatrixClass a => a -> IO Bool -dmatrix_isDense x = casadi__DMatrix__isDense (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isEmpty__0" c_casadi__DMatrix__isEmpty__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isEmpty__0 - :: DMatrix -> IO Bool -casadi__DMatrix__isEmpty__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isEmpty__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isEmpty__0 :: DMatrixClass a => a -> IO Bool -dmatrix_isEmpty__0 x = casadi__DMatrix__isEmpty__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isEmpty__1" c_casadi__DMatrix__isEmpty__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__isEmpty__1 - :: DMatrix -> Bool -> IO Bool -casadi__DMatrix__isEmpty__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isEmpty__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isEmpty__1 :: DMatrixClass a => a -> Bool -> IO Bool -dmatrix_isEmpty__1 x = casadi__DMatrix__isEmpty__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isIdentity" c_casadi__DMatrix__isIdentity - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isIdentity - :: DMatrix -> IO Bool -casadi__DMatrix__isIdentity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isIdentity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isIdentity :: DMatrixClass a => a -> IO Bool -dmatrix_isIdentity x = casadi__DMatrix__isIdentity (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isInteger" c_casadi__DMatrix__isInteger - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isInteger - :: DMatrix -> IO Bool -casadi__DMatrix__isInteger x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isInteger errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isInteger :: DMatrixClass a => a -> IO Bool -dmatrix_isInteger x = casadi__DMatrix__isInteger (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isLeaf" c_casadi__DMatrix__isLeaf - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isLeaf - :: DMatrix -> IO Bool -casadi__DMatrix__isLeaf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isLeaf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isLeaf :: DMatrixClass a => a -> IO Bool -dmatrix_isLeaf x = casadi__DMatrix__isLeaf (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isMinusOne" c_casadi__DMatrix__isMinusOne - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isMinusOne - :: DMatrix -> IO Bool -casadi__DMatrix__isMinusOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isMinusOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isMinusOne :: DMatrixClass a => a -> IO Bool -dmatrix_isMinusOne x = casadi__DMatrix__isMinusOne (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isOne" c_casadi__DMatrix__isOne - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isOne - :: DMatrix -> IO Bool -casadi__DMatrix__isOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isOne :: DMatrixClass a => a -> IO Bool -dmatrix_isOne x = casadi__DMatrix__isOne (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isRegular" c_casadi__DMatrix__isRegular - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isRegular - :: DMatrix -> IO Bool -casadi__DMatrix__isRegular x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isRegular errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isRegular :: DMatrixClass a => a -> IO Bool -dmatrix_isRegular x = casadi__DMatrix__isRegular (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isRowVector" c_casadi__DMatrix__isRowVector - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isRowVector - :: DMatrix -> IO Bool -casadi__DMatrix__isRowVector x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isRowVector errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isRowVector :: DMatrixClass a => a -> IO Bool -dmatrix_isRowVector x = casadi__DMatrix__isRowVector (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isScalar__0" c_casadi__DMatrix__isScalar__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isScalar__0 - :: DMatrix -> IO Bool -casadi__DMatrix__isScalar__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isScalar__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isScalar__0 :: DMatrixClass a => a -> IO Bool -dmatrix_isScalar__0 x = casadi__DMatrix__isScalar__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isScalar__1" c_casadi__DMatrix__isScalar__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__isScalar__1 - :: DMatrix -> Bool -> IO Bool -casadi__DMatrix__isScalar__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isScalar__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isScalar__1 :: DMatrixClass a => a -> Bool -> IO Bool -dmatrix_isScalar__1 x = casadi__DMatrix__isScalar__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isSlice__0" c_casadi__DMatrix__isSlice__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isSlice__0 - :: DMatrix -> IO Bool -casadi__DMatrix__isSlice__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isSlice__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isSlice__0 :: DMatrixClass a => a -> IO Bool -dmatrix_isSlice__0 x = casadi__DMatrix__isSlice__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isSlice__1" c_casadi__DMatrix__isSlice__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__isSlice__1 - :: DMatrix -> Bool -> IO Bool -casadi__DMatrix__isSlice__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isSlice__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isSlice__1 :: DMatrixClass a => a -> Bool -> IO Bool -dmatrix_isSlice__1 x = casadi__DMatrix__isSlice__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isSmooth" c_casadi__DMatrix__isSmooth - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isSmooth - :: DMatrix -> IO Bool -casadi__DMatrix__isSmooth x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isSmooth errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isSmooth :: DMatrixClass a => a -> IO Bool -dmatrix_isSmooth x = casadi__DMatrix__isSmooth (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isSquare" c_casadi__DMatrix__isSquare - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isSquare - :: DMatrix -> IO Bool -casadi__DMatrix__isSquare x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isSquare errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isSquare :: DMatrixClass a => a -> IO Bool -dmatrix_isSquare x = casadi__DMatrix__isSquare (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isSymbolic" c_casadi__DMatrix__isSymbolic - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isSymbolic - :: DMatrix -> IO Bool -casadi__DMatrix__isSymbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isSymbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isSymbolic :: DMatrixClass a => a -> IO Bool -dmatrix_isSymbolic x = casadi__DMatrix__isSymbolic (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isSymbolicSparse" c_casadi__DMatrix__isSymbolicSparse - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isSymbolicSparse - :: DMatrix -> IO Bool -casadi__DMatrix__isSymbolicSparse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isSymbolicSparse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isSymbolicSparse :: DMatrixClass a => a -> IO Bool -dmatrix_isSymbolicSparse x = casadi__DMatrix__isSymbolicSparse (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isTril" c_casadi__DMatrix__isTril - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isTril - :: DMatrix -> IO Bool -casadi__DMatrix__isTril x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isTril errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isTril :: DMatrixClass a => a -> IO Bool -dmatrix_isTril x = casadi__DMatrix__isTril (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isTriu" c_casadi__DMatrix__isTriu - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isTriu - :: DMatrix -> IO Bool -casadi__DMatrix__isTriu x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isTriu errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isTriu :: DMatrixClass a => a -> IO Bool -dmatrix_isTriu x = casadi__DMatrix__isTriu (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isVector__0" c_casadi__DMatrix__isVector__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isVector__0 - :: DMatrix -> IO Bool -casadi__DMatrix__isVector__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isVector__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isVector__0 :: DMatrixClass a => a -> IO Bool -dmatrix_isVector__0 x = casadi__DMatrix__isVector__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isVector__1" c_casadi__DMatrix__isVector__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__isVector__1 - :: DMatrix -> Bool -> IO Bool -casadi__DMatrix__isVector__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isVector__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isVector__1 :: DMatrixClass a => a -> Bool -> IO Bool -dmatrix_isVector__1 x = casadi__DMatrix__isVector__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__isZero" c_casadi__DMatrix__isZero - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__isZero - :: DMatrix -> IO Bool -casadi__DMatrix__isZero x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__isZero errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_isZero :: DMatrixClass a => a -> IO Bool -dmatrix_isZero x = casadi__DMatrix__isZero (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__makeSparse__0" c_casadi__DMatrix__makeSparse__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__makeSparse__0 - :: DMatrix -> IO () -casadi__DMatrix__makeSparse__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__makeSparse__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_makeSparse__0 :: DMatrixClass a => a -> IO () -dmatrix_makeSparse__0 x = casadi__DMatrix__makeSparse__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__makeSparse__1" c_casadi__DMatrix__makeSparse__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () -casadi__DMatrix__makeSparse__1 - :: DMatrix -> Double -> IO () -casadi__DMatrix__makeSparse__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__makeSparse__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_makeSparse__1 :: DMatrixClass a => a -> Double -> IO () -dmatrix_makeSparse__1 x = casadi__DMatrix__makeSparse__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__matrix_matrix" c_casadi__DMatrix__matrix_matrix - :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__matrix_matrix - :: Int -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__matrix_matrix x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__matrix_matrix errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_matrix_matrix = casadi__DMatrix__matrix_matrix - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__matrix_scalar" c_casadi__DMatrix__matrix_scalar - :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__matrix_scalar - :: Int -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__matrix_scalar x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__matrix_scalar errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_matrix_scalar = casadi__DMatrix__matrix_scalar - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__nan__0" c_casadi__DMatrix__nan__0 - :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') -casadi__DMatrix__nan__0 - :: IO DMatrix -casadi__DMatrix__nan__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__nan__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_nan__0 :: IO DMatrix -dmatrix_nan__0 = casadi__DMatrix__nan__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__nan__1" c_casadi__DMatrix__nan__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__nan__1 - :: Int -> IO DMatrix -casadi__DMatrix__nan__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__nan__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_nan__1 :: Int -> IO DMatrix -dmatrix_nan__1 = casadi__DMatrix__nan__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__nan__2" c_casadi__DMatrix__nan__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__nan__2 - :: Int -> Int -> IO DMatrix -casadi__DMatrix__nan__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__nan__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_nan__2 :: Int -> Int -> IO DMatrix -dmatrix_nan__2 = casadi__DMatrix__nan__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__nan__3" c_casadi__DMatrix__nan__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__nan__3 - :: Sparsity -> IO DMatrix -casadi__DMatrix__nan__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__nan__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_nan__3 :: Sparsity -> IO DMatrix -dmatrix_nan__3 = casadi__DMatrix__nan__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__nnz" c_casadi__DMatrix__nnz - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__nnz - :: DMatrix -> IO Int -casadi__DMatrix__nnz x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__nnz errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_nnz :: DMatrixClass a => a -> IO Int -dmatrix_nnz x = casadi__DMatrix__nnz (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__nonzeros" c_casadi__DMatrix__nonzeros - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CDouble)) -casadi__DMatrix__nonzeros - :: DMatrix -> IO (Vector Double) -casadi__DMatrix__nonzeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__nonzeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_nonzeros :: DMatrixClass a => a -> IO (Vector Double) -dmatrix_nonzeros x = casadi__DMatrix__nonzeros (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__nonzeros_int" c_casadi__DMatrix__nonzeros_int - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) -casadi__DMatrix__nonzeros_int - :: DMatrix -> IO (Vector Int) -casadi__DMatrix__nonzeros_int x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__nonzeros_int errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_nonzeros_int :: DMatrixClass a => a -> IO (Vector Int) -dmatrix_nonzeros_int x = casadi__DMatrix__nonzeros_int (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__numel__0" c_casadi__DMatrix__numel__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__numel__0 - :: DMatrix -> Int -> IO Int -casadi__DMatrix__numel__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__numel__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_numel__0 :: DMatrixClass a => a -> Int -> IO Int -dmatrix_numel__0 x = casadi__DMatrix__numel__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__numel__1" c_casadi__DMatrix__numel__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__numel__1 - :: DMatrix -> IO Int -casadi__DMatrix__numel__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__numel__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_numel__1 :: DMatrixClass a => a -> IO Int -dmatrix_numel__1 x = casadi__DMatrix__numel__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__ones__0" c_casadi__DMatrix__ones__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__ones__0 - :: Sparsity -> IO DMatrix -casadi__DMatrix__ones__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__ones__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_ones__0 :: Sparsity -> IO DMatrix -dmatrix_ones__0 = casadi__DMatrix__ones__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__ones__1" c_casadi__DMatrix__ones__1 - :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') -casadi__DMatrix__ones__1 - :: IO DMatrix -casadi__DMatrix__ones__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__ones__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_ones__1 :: IO DMatrix -dmatrix_ones__1 = casadi__DMatrix__ones__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__ones__2" c_casadi__DMatrix__ones__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__ones__2 - :: Int -> IO DMatrix -casadi__DMatrix__ones__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__ones__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_ones__2 :: Int -> IO DMatrix -dmatrix_ones__2 = casadi__DMatrix__ones__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__ones__3" c_casadi__DMatrix__ones__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__ones__3 - :: Int -> Int -> IO DMatrix -casadi__DMatrix__ones__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__ones__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_ones__3 :: Int -> Int -> IO DMatrix -dmatrix_ones__3 = casadi__DMatrix__ones__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__operator_plus" c_casadi__DMatrix__operator_plus - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__operator_plus - :: DMatrix -> IO DMatrix -casadi__DMatrix__operator_plus x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__operator_plus errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_operator_plus :: DMatrixClass a => a -> IO DMatrix -dmatrix_operator_plus x = casadi__DMatrix__operator_plus (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__operator_minus" c_casadi__DMatrix__operator_minus - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__operator_minus - :: DMatrix -> IO DMatrix -casadi__DMatrix__operator_minus x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__operator_minus errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_operator_minus :: DMatrixClass a => a -> IO DMatrix -dmatrix_operator_minus x = casadi__DMatrix__operator_minus (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__printDense" c_casadi__DMatrix__printDense - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__printDense - :: DMatrix -> IO () -casadi__DMatrix__printDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__printDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_printDense :: DMatrixClass a => a -> IO () -dmatrix_printDense x = casadi__DMatrix__printDense (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__printScalar" c_casadi__DMatrix__printScalar - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__printScalar - :: DMatrix -> IO () -casadi__DMatrix__printScalar x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__printScalar errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_printScalar :: DMatrixClass a => a -> IO () -dmatrix_printScalar x = casadi__DMatrix__printScalar (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__printSparse" c_casadi__DMatrix__printSparse - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__printSparse - :: DMatrix -> IO () -casadi__DMatrix__printSparse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__printSparse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_printSparse :: DMatrixClass a => a -> IO () -dmatrix_printSparse x = casadi__DMatrix__printSparse (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__printVector" c_casadi__DMatrix__printVector - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__printVector - :: DMatrix -> IO () -casadi__DMatrix__printVector x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__printVector errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_printVector :: DMatrixClass a => a -> IO () -dmatrix_printVector x = casadi__DMatrix__printVector (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__printme" c_casadi__DMatrix__printme - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__printme - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__printme x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__printme errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_printme :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_printme x = casadi__DMatrix__printme (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__remove" c_casadi__DMatrix__remove - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__DMatrix__remove - :: DMatrix -> Vector Int -> Vector Int -> IO () -casadi__DMatrix__remove x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__remove errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_remove :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO () -dmatrix_remove x = casadi__DMatrix__remove (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__reserve__0" c_casadi__DMatrix__reserve__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO () -casadi__DMatrix__reserve__0 - :: DMatrix -> Int -> Int -> IO () -casadi__DMatrix__reserve__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__reserve__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_reserve__0 :: DMatrixClass a => a -> Int -> Int -> IO () -dmatrix_reserve__0 x = casadi__DMatrix__reserve__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__reserve__1" c_casadi__DMatrix__reserve__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO () -casadi__DMatrix__reserve__1 - :: DMatrix -> Int -> IO () -casadi__DMatrix__reserve__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__reserve__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_reserve__1 :: DMatrixClass a => a -> Int -> IO () -dmatrix_reserve__1 x = casadi__DMatrix__reserve__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__resize" c_casadi__DMatrix__resize - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO () -casadi__DMatrix__resize - :: DMatrix -> Int -> Int -> IO () -casadi__DMatrix__resize x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__resize errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_resize :: DMatrixClass a => a -> Int -> Int -> IO () -dmatrix_resize x = casadi__DMatrix__resize (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__row" c_casadi__DMatrix__row - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__row - :: DMatrix -> Int -> IO Int -casadi__DMatrix__row x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__row errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_row :: DMatrixClass a => a -> Int -> IO Int -dmatrix_row x = casadi__DMatrix__row (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sanityCheck__0" c_casadi__DMatrix__sanityCheck__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__sanityCheck__0 - :: DMatrix -> IO () -casadi__DMatrix__sanityCheck__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sanityCheck__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sanityCheck__0 :: DMatrixClass a => a -> IO () -dmatrix_sanityCheck__0 x = casadi__DMatrix__sanityCheck__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sanityCheck__1" c_casadi__DMatrix__sanityCheck__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO () -casadi__DMatrix__sanityCheck__1 - :: DMatrix -> Bool -> IO () -casadi__DMatrix__sanityCheck__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sanityCheck__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sanityCheck__1 :: DMatrixClass a => a -> Bool -> IO () -dmatrix_sanityCheck__1 x = casadi__DMatrix__sanityCheck__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__scalar_matrix" c_casadi__DMatrix__scalar_matrix - :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__scalar_matrix - :: Int -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__scalar_matrix x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__scalar_matrix errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_scalar_matrix = casadi__DMatrix__scalar_matrix - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__0" c_casadi__DMatrix__set__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__DMatrix__set__0 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () -casadi__DMatrix__set__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () -dmatrix_set__0 x = casadi__DMatrix__set__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__1" c_casadi__DMatrix__set__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__DMatrix__set__1 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> Slice -> IO () -casadi__DMatrix__set__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__1 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> Slice -> IO () -dmatrix_set__1 x = casadi__DMatrix__set__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__2" c_casadi__DMatrix__set__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__DMatrix__set__2 - :: DMatrix -> DMatrix -> Bool -> Slice -> IMatrix -> IO () -casadi__DMatrix__set__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__2 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IMatrix -> IO () -dmatrix_set__2 x = casadi__DMatrix__set__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__3" c_casadi__DMatrix__set__3 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__DMatrix__set__3 - :: DMatrix -> DMatrix -> Bool -> Slice -> Slice -> IO () -casadi__DMatrix__set__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__3 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> Slice -> IO () -dmatrix_set__3 x = casadi__DMatrix__set__3 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__4" c_casadi__DMatrix__set__4 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Sparsity' -> IO () -casadi__DMatrix__set__4 - :: DMatrix -> DMatrix -> Bool -> Sparsity -> IO () -casadi__DMatrix__set__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__4 :: DMatrixClass a => a -> DMatrix -> Bool -> Sparsity -> IO () -dmatrix_set__4 x = casadi__DMatrix__set__4 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__5" c_casadi__DMatrix__set__5 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__DMatrix__set__5 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () -casadi__DMatrix__set__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__5 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () -dmatrix_set__5 x = casadi__DMatrix__set__5 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__6" c_casadi__DMatrix__set__6 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__DMatrix__set__6 - :: DMatrix -> DMatrix -> Bool -> Slice -> IO () -casadi__DMatrix__set__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__6 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () -dmatrix_set__6 x = casadi__DMatrix__set__6 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__7" c_casadi__DMatrix__set__7 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__DMatrix__set__7 - :: DMatrix -> Vector Double -> IO () -casadi__DMatrix__set__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__7 :: DMatrixClass a => a -> Vector Double -> IO () -dmatrix_set__7 x = casadi__DMatrix__set__7 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__8" c_casadi__DMatrix__set__8 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__DMatrix__set__8 - :: DMatrix -> Vector Double -> Bool -> IO () -casadi__DMatrix__set__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__8 :: DMatrixClass a => a -> Vector Double -> Bool -> IO () -dmatrix_set__8 x = casadi__DMatrix__set__8 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__9" c_casadi__DMatrix__set__9 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () -casadi__DMatrix__set__9 - :: DMatrix -> Double -> IO () -casadi__DMatrix__set__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__9 :: DMatrixClass a => a -> Double -> IO () -dmatrix_set__9 x = casadi__DMatrix__set__9 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__set__10" c_casadi__DMatrix__set__10 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO () -casadi__DMatrix__set__10 - :: DMatrix -> DMatrix -> IO () -casadi__DMatrix__set__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__set__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_set__10 :: DMatrixClass a => a -> DMatrix -> IO () -dmatrix_set__10 x = casadi__DMatrix__set__10 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setEqualityCheckingDepth__0" c_casadi__DMatrix__setEqualityCheckingDepth__0 - :: Ptr (Ptr StdString) -> IO () -casadi__DMatrix__setEqualityCheckingDepth__0 - :: IO () -casadi__DMatrix__setEqualityCheckingDepth__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setEqualityCheckingDepth__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setEqualityCheckingDepth__0 :: IO () -dmatrix_setEqualityCheckingDepth__0 = casadi__DMatrix__setEqualityCheckingDepth__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setEqualityCheckingDepth__1" c_casadi__DMatrix__setEqualityCheckingDepth__1 - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__DMatrix__setEqualityCheckingDepth__1 - :: Int -> IO () -casadi__DMatrix__setEqualityCheckingDepth__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setEqualityCheckingDepth__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setEqualityCheckingDepth__1 :: Int -> IO () -dmatrix_setEqualityCheckingDepth__1 = casadi__DMatrix__setEqualityCheckingDepth__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setMaxNumCallsInPrint__0" c_casadi__DMatrix__setMaxNumCallsInPrint__0 - :: Ptr (Ptr StdString) -> IO () -casadi__DMatrix__setMaxNumCallsInPrint__0 - :: IO () -casadi__DMatrix__setMaxNumCallsInPrint__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setMaxNumCallsInPrint__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setMaxNumCallsInPrint__0 :: IO () -dmatrix_setMaxNumCallsInPrint__0 = casadi__DMatrix__setMaxNumCallsInPrint__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setMaxNumCallsInPrint__1" c_casadi__DMatrix__setMaxNumCallsInPrint__1 - :: Ptr (Ptr StdString) -> CLong -> IO () -casadi__DMatrix__setMaxNumCallsInPrint__1 - :: Int -> IO () -casadi__DMatrix__setMaxNumCallsInPrint__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setMaxNumCallsInPrint__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setMaxNumCallsInPrint__1 :: Int -> IO () -dmatrix_setMaxNumCallsInPrint__1 = casadi__DMatrix__setMaxNumCallsInPrint__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setNZ__0" c_casadi__DMatrix__setNZ__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__DMatrix__setNZ__0 - :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () -casadi__DMatrix__setNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setNZ__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () -dmatrix_setNZ__0 x = casadi__DMatrix__setNZ__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setNZ__1" c_casadi__DMatrix__setNZ__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__DMatrix__setNZ__1 - :: DMatrix -> DMatrix -> Bool -> Slice -> IO () -casadi__DMatrix__setNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setNZ__1 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () -dmatrix_setNZ__1 x = casadi__DMatrix__setNZ__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setNZ__2" c_casadi__DMatrix__setNZ__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__DMatrix__setNZ__2 - :: DMatrix -> Vector Double -> IO () -casadi__DMatrix__setNZ__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setNZ__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setNZ__2 :: DMatrixClass a => a -> Vector Double -> IO () -dmatrix_setNZ__2 x = casadi__DMatrix__setNZ__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setNZ__3" c_casadi__DMatrix__setNZ__3 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () -casadi__DMatrix__setNZ__3 - :: DMatrix -> Double -> IO () -casadi__DMatrix__setNZ__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setNZ__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setNZ__3 :: DMatrixClass a => a -> Double -> IO () -dmatrix_setNZ__3 x = casadi__DMatrix__setNZ__3 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setPrecision" c_casadi__DMatrix__setPrecision - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__DMatrix__setPrecision - :: Int -> IO () -casadi__DMatrix__setPrecision x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setPrecision errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setPrecision :: Int -> IO () -dmatrix_setPrecision = casadi__DMatrix__setPrecision - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setScientific" c_casadi__DMatrix__setScientific - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__DMatrix__setScientific - :: Bool -> IO () -casadi__DMatrix__setScientific x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setScientific errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setScientific :: Bool -> IO () -dmatrix_setScientific = casadi__DMatrix__setScientific - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setSparse__0" c_casadi__DMatrix__setSparse__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__setSparse__0 - :: DMatrix -> Sparsity -> IO DMatrix -casadi__DMatrix__setSparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setSparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setSparse__0 :: DMatrixClass a => a -> Sparsity -> IO DMatrix -dmatrix_setSparse__0 x = casadi__DMatrix__setSparse__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setSparse__1" c_casadi__DMatrix__setSparse__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__setSparse__1 - :: DMatrix -> Sparsity -> Bool -> IO DMatrix -casadi__DMatrix__setSparse__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setSparse__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setSparse__1 :: DMatrixClass a => a -> Sparsity -> Bool -> IO DMatrix -dmatrix_setSparse__1 x = casadi__DMatrix__setSparse__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setSym" c_casadi__DMatrix__setSym - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__DMatrix__setSym - :: DMatrix -> Vector Double -> IO () -casadi__DMatrix__setSym x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setSym errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setSym :: DMatrixClass a => a -> Vector Double -> IO () -dmatrix_setSym x = casadi__DMatrix__setSym (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setValue__0" c_casadi__DMatrix__setValue__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> CInt -> IO () -casadi__DMatrix__setValue__0 - :: DMatrix -> Double -> Int -> IO () -casadi__DMatrix__setValue__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setValue__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setValue__0 :: DMatrixClass a => a -> Double -> Int -> IO () -dmatrix_setValue__0 x = casadi__DMatrix__setValue__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setValue__1" c_casadi__DMatrix__setValue__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () -casadi__DMatrix__setValue__1 - :: DMatrix -> Double -> IO () -casadi__DMatrix__setValue__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setValue__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setValue__1 :: DMatrixClass a => a -> Double -> IO () -dmatrix_setValue__1 x = casadi__DMatrix__setValue__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setWidth" c_casadi__DMatrix__setWidth - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__DMatrix__setWidth - :: Int -> IO () -casadi__DMatrix__setWidth x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setWidth errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setWidth :: Int -> IO () -dmatrix_setWidth = casadi__DMatrix__setWidth - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__setZero" c_casadi__DMatrix__setZero - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__setZero - :: DMatrix -> IO () -casadi__DMatrix__setZero x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__setZero errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_setZero :: DMatrixClass a => a -> IO () -dmatrix_setZero x = casadi__DMatrix__setZero (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__size__0" c_casadi__DMatrix__size__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__size__0 - :: DMatrix -> SparsityType -> IO Int -casadi__DMatrix__size__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__size__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_size__0 :: DMatrixClass a => a -> SparsityType -> IO Int -dmatrix_size__0 x = casadi__DMatrix__size__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__size__1" c_casadi__DMatrix__size__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__size__1 - :: DMatrix -> IO Int -casadi__DMatrix__size__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__size__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_size__1 :: DMatrixClass a => a -> IO Int -dmatrix_size__1 x = casadi__DMatrix__size__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__size1" c_casadi__DMatrix__size1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__size1 - :: DMatrix -> IO Int -casadi__DMatrix__size1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__size1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_size1 :: DMatrixClass a => a -> IO Int -dmatrix_size1 x = casadi__DMatrix__size1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__size2" c_casadi__DMatrix__size2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__size2 - :: DMatrix -> IO Int -casadi__DMatrix__size2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__size2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_size2 :: DMatrixClass a => a -> IO Int -dmatrix_size2 x = casadi__DMatrix__size2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sizeD" c_casadi__DMatrix__sizeD - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__sizeD - :: DMatrix -> IO Int -casadi__DMatrix__sizeD x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sizeD errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sizeD :: DMatrixClass a => a -> IO Int -dmatrix_sizeD x = casadi__DMatrix__sizeD (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sizeL" c_casadi__DMatrix__sizeL - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__sizeL - :: DMatrix -> IO Int -casadi__DMatrix__sizeL x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sizeL errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sizeL :: DMatrixClass a => a -> IO Int -dmatrix_sizeL x = casadi__DMatrix__sizeL (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sizeU" c_casadi__DMatrix__sizeU - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__sizeU - :: DMatrix -> IO Int -casadi__DMatrix__sizeU x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sizeU errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sizeU :: DMatrixClass a => a -> IO Int -dmatrix_sizeU x = casadi__DMatrix__sizeU (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sparse__0" c_casadi__DMatrix__sparse__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__sparse__0 - :: Sparsity -> DMatrix -> IO DMatrix -casadi__DMatrix__sparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sparse__0 :: Sparsity -> DMatrix -> IO DMatrix -dmatrix_sparse__0 = casadi__DMatrix__sparse__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sparse__1" c_casadi__DMatrix__sparse__1 - :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') -casadi__DMatrix__sparse__1 - :: IO DMatrix -casadi__DMatrix__sparse__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sparse__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sparse__1 :: IO DMatrix -dmatrix_sparse__1 = casadi__DMatrix__sparse__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sparse__2" c_casadi__DMatrix__sparse__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__sparse__2 - :: Int -> IO DMatrix -casadi__DMatrix__sparse__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sparse__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sparse__2 :: Int -> IO DMatrix -dmatrix_sparse__2 = casadi__DMatrix__sparse__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sparse__3" c_casadi__DMatrix__sparse__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__sparse__3 - :: Int -> Int -> IO DMatrix -casadi__DMatrix__sparse__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sparse__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sparse__3 :: Int -> Int -> IO DMatrix -dmatrix_sparse__3 = casadi__DMatrix__sparse__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sparsity" c_casadi__DMatrix__sparsity - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Sparsity') -casadi__DMatrix__sparsity - :: DMatrix -> IO Sparsity -casadi__DMatrix__sparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sparsity :: DMatrixClass a => a -> IO Sparsity -dmatrix_sparsity x = casadi__DMatrix__sparsity (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sparsityRef" c_casadi__DMatrix__sparsityRef - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Sparsity') -casadi__DMatrix__sparsityRef - :: DMatrix -> IO Sparsity -casadi__DMatrix__sparsityRef x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sparsityRef errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sparsityRef :: DMatrixClass a => a -> IO Sparsity -dmatrix_sparsityRef x = casadi__DMatrix__sparsityRef (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__0" c_casadi__DMatrix__sym__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) -casadi__DMatrix__sym__0 - :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix)) -casadi__DMatrix__sym__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix)) -dmatrix_sym__0 = casadi__DMatrix__sym__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__1" c_casadi__DMatrix__sym__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) -casadi__DMatrix__sym__1 - :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix)) -casadi__DMatrix__sym__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix)) -dmatrix_sym__1 = casadi__DMatrix__sym__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__2" c_casadi__DMatrix__sym__2 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__sym__2 - :: String -> Int -> Int -> Int -> IO (Vector DMatrix) -casadi__DMatrix__sym__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector DMatrix) -dmatrix_sym__2 = casadi__DMatrix__sym__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__3" c_casadi__DMatrix__sym__3 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__sym__3 - :: String -> Sparsity -> Int -> IO (Vector DMatrix) -casadi__DMatrix__sym__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector DMatrix) -dmatrix_sym__3 = casadi__DMatrix__sym__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__4" c_casadi__DMatrix__sym__4 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__sym__4 - :: String -> Sparsity -> IO DMatrix -casadi__DMatrix__sym__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__4 :: String -> Sparsity -> IO DMatrix -dmatrix_sym__4 = casadi__DMatrix__sym__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__5" c_casadi__DMatrix__sym__5 - :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr DMatrix') -casadi__DMatrix__sym__5 - :: String -> IO DMatrix -casadi__DMatrix__sym__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__5 :: String -> IO DMatrix -dmatrix_sym__5 = casadi__DMatrix__sym__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__6" c_casadi__DMatrix__sym__6 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__sym__6 - :: String -> Int -> IO DMatrix -casadi__DMatrix__sym__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__6 :: String -> Int -> IO DMatrix -dmatrix_sym__6 = casadi__DMatrix__sym__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__sym__7" c_casadi__DMatrix__sym__7 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__sym__7 - :: String -> Int -> Int -> IO DMatrix -casadi__DMatrix__sym__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__sym__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_sym__7 :: String -> Int -> Int -> IO DMatrix -dmatrix_sym__7 = casadi__DMatrix__sym__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__toSlice__0" c_casadi__DMatrix__toSlice__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Slice') -casadi__DMatrix__toSlice__0 - :: DMatrix -> IO Slice -casadi__DMatrix__toSlice__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__toSlice__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_toSlice__0 :: DMatrixClass a => a -> IO Slice -dmatrix_toSlice__0 x = casadi__DMatrix__toSlice__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__toSlice__1" c_casadi__DMatrix__toSlice__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr Slice') -casadi__DMatrix__toSlice__1 - :: DMatrix -> Bool -> IO Slice -casadi__DMatrix__toSlice__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__toSlice__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_toSlice__1 :: DMatrixClass a => a -> Bool -> IO Slice -dmatrix_toSlice__1 x = casadi__DMatrix__toSlice__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__triplet__0" c_casadi__DMatrix__triplet__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__triplet__0 - :: Vector Int -> Vector Int -> DMatrix -> Int -> Int -> IO DMatrix -casadi__DMatrix__triplet__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__triplet__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_triplet__0 :: Vector Int -> Vector Int -> DMatrix -> Int -> Int -> IO DMatrix -dmatrix_triplet__0 = casadi__DMatrix__triplet__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__triplet__1" c_casadi__DMatrix__triplet__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__triplet__1 - :: Vector Int -> Vector Int -> DMatrix -> IO DMatrix -casadi__DMatrix__triplet__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__triplet__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_triplet__1 :: Vector Int -> Vector Int -> DMatrix -> IO DMatrix -dmatrix_triplet__1 = casadi__DMatrix__triplet__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__unary" c_casadi__DMatrix__unary - :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__unary - :: Int -> DMatrix -> IO DMatrix -casadi__DMatrix__unary x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__unary errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_unary :: Int -> DMatrix -> IO DMatrix -dmatrix_unary = casadi__DMatrix__unary - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zeros__0" c_casadi__DMatrix__zeros__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__zeros__0 - :: Sparsity -> IO DMatrix -casadi__DMatrix__zeros__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zeros__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zeros__0 :: Sparsity -> IO DMatrix -dmatrix_zeros__0 = casadi__DMatrix__zeros__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zeros__1" c_casadi__DMatrix__zeros__1 - :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') -casadi__DMatrix__zeros__1 - :: IO DMatrix -casadi__DMatrix__zeros__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zeros__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zeros__1 :: IO DMatrix -dmatrix_zeros__1 = casadi__DMatrix__zeros__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zeros__2" c_casadi__DMatrix__zeros__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zeros__2 - :: Int -> IO DMatrix -casadi__DMatrix__zeros__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zeros__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zeros__2 :: Int -> IO DMatrix -dmatrix_zeros__2 = casadi__DMatrix__zeros__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zeros__3" c_casadi__DMatrix__zeros__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zeros__3 - :: Int -> Int -> IO DMatrix -casadi__DMatrix__zeros__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zeros__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zeros__3 :: Int -> Int -> IO DMatrix -dmatrix_zeros__3 = casadi__DMatrix__zeros__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_abs" c_casadi__DMatrix__zz_abs - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_abs - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_abs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_abs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_abs :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_abs x = casadi__DMatrix__zz_abs (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_acos" c_casadi__DMatrix__zz_acos - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_acos - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_acos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_acos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_acos :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_acos x = casadi__DMatrix__zz_acos (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_acosh" c_casadi__DMatrix__zz_acosh - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_acosh - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_acosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_acosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_acosh :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_acosh x = casadi__DMatrix__zz_acosh (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_adj" c_casadi__DMatrix__zz_adj - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_adj - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_adj x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_adj errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_adj :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_adj x = casadi__DMatrix__zz_adj (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_all" c_casadi__DMatrix__zz_all - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_all - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_all x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_all errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_all :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_all x = casadi__DMatrix__zz_all (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_and" c_casadi__DMatrix__zz_and - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_and - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_and x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_and errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_and :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_and x = casadi__DMatrix__zz_and (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_any" c_casadi__DMatrix__zz_any - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_any - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_any x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_any errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_any :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_any x = casadi__DMatrix__zz_any (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_asin" c_casadi__DMatrix__zz_asin - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_asin - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_asin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_asin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_asin :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_asin x = casadi__DMatrix__zz_asin (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_asinh" c_casadi__DMatrix__zz_asinh - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_asinh - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_asinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_asinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_asinh :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_asinh x = casadi__DMatrix__zz_asinh (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_atan" c_casadi__DMatrix__zz_atan - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_atan - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_atan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_atan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_atan :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_atan x = casadi__DMatrix__zz_atan (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_atan2" c_casadi__DMatrix__zz_atan2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_atan2 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_atan2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_atan2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_atan2 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_atan2 x = casadi__DMatrix__zz_atan2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_atanh" c_casadi__DMatrix__zz_atanh - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_atanh - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_atanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_atanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_atanh :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_atanh x = casadi__DMatrix__zz_atanh (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_blockcat" c_casadi__DMatrix__zz_blockcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO (Ptr DMatrix') -casadi__DMatrix__zz_blockcat - :: Vector (Vector DMatrix) -> IO DMatrix -casadi__DMatrix__zz_blockcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_blockcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_blockcat :: Vector (Vector DMatrix) -> IO DMatrix -dmatrix_zz_blockcat = casadi__DMatrix__zz_blockcat - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_blocksplit" c_casadi__DMatrix__zz_blocksplit - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) -casadi__DMatrix__zz_blocksplit - :: DMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix)) -casadi__DMatrix__zz_blocksplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_blocksplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_blocksplit :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix)) -dmatrix_zz_blocksplit x = casadi__DMatrix__zz_blocksplit (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_ceil" c_casadi__DMatrix__zz_ceil - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_ceil - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_ceil x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_ceil errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_ceil :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_ceil x = casadi__DMatrix__zz_ceil (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_cofactor" c_casadi__DMatrix__zz_cofactor - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_cofactor - :: DMatrix -> Int -> Int -> IO DMatrix -casadi__DMatrix__zz_cofactor x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_cofactor errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_cofactor :: DMatrixClass a => a -> Int -> Int -> IO DMatrix -dmatrix_zz_cofactor x = casadi__DMatrix__zz_cofactor (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_cos" c_casadi__DMatrix__zz_cos - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_cos - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_cos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_cos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_cos :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_cos x = casadi__DMatrix__zz_cos (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_cosh" c_casadi__DMatrix__zz_cosh - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_cosh - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_cosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_cosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_cosh :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_cosh x = casadi__DMatrix__zz_cosh (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_countNodes" c_casadi__DMatrix__zz_countNodes - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__zz_countNodes - :: DMatrix -> IO Int -casadi__DMatrix__zz_countNodes x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_countNodes errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_countNodes :: DMatrixClass a => a -> IO Int -dmatrix_zz_countNodes x = casadi__DMatrix__zz_countNodes (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_cross__0" c_casadi__DMatrix__zz_cross__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_cross__0 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_cross__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_cross__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_cross__0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_cross__0 x = casadi__DMatrix__zz_cross__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_cross__1" c_casadi__DMatrix__zz_cross__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_cross__1 - :: DMatrix -> DMatrix -> Int -> IO DMatrix -casadi__DMatrix__zz_cross__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_cross__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_cross__1 :: DMatrixClass a => a -> DMatrix -> Int -> IO DMatrix -dmatrix_zz_cross__1 x = casadi__DMatrix__zz_cross__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_densify" c_casadi__DMatrix__zz_densify - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_densify - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_densify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_densify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_densify :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_densify x = casadi__DMatrix__zz_densify (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_dependsOn" c_casadi__DMatrix__zz_dependsOn - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__zz_dependsOn - :: DMatrix -> DMatrix -> IO Bool -casadi__DMatrix__zz_dependsOn x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_dependsOn errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_dependsOn :: DMatrixClass a => a -> DMatrix -> IO Bool -dmatrix_zz_dependsOn x = casadi__DMatrix__zz_dependsOn (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_det" c_casadi__DMatrix__zz_det - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_det - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_det x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_det errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_det :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_det x = casadi__DMatrix__zz_det (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_diag" c_casadi__DMatrix__zz_diag - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_diag - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_diag x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_diag errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_diag :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_diag x = casadi__DMatrix__zz_diag (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_diagcat" c_casadi__DMatrix__zz_diagcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') -casadi__DMatrix__zz_diagcat - :: Vector DMatrix -> IO DMatrix -casadi__DMatrix__zz_diagcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_diagcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_diagcat :: Vector DMatrix -> IO DMatrix -dmatrix_zz_diagcat = casadi__DMatrix__zz_diagcat - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_diagsplit" c_casadi__DMatrix__zz_diagsplit - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__zz_diagsplit - :: DMatrix -> Vector Int -> Vector Int -> IO (Vector DMatrix) -casadi__DMatrix__zz_diagsplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_diagsplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_diagsplit :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO (Vector DMatrix) -dmatrix_zz_diagsplit x = casadi__DMatrix__zz_diagsplit (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_eig_symbolic" c_casadi__DMatrix__zz_eig_symbolic - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_eig_symbolic - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_eig_symbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_eig_symbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_eig_symbolic :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_eig_symbolic x = casadi__DMatrix__zz_eig_symbolic (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_eq" c_casadi__DMatrix__zz_eq - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_eq - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_eq x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_eq errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_eq :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_eq x = casadi__DMatrix__zz_eq (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_erf" c_casadi__DMatrix__zz_erf - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_erf - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_erf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_erf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_erf :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_erf x = casadi__DMatrix__zz_erf (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_erfinv" c_casadi__DMatrix__zz_erfinv - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_erfinv - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_erfinv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_erfinv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_erfinv :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_erfinv x = casadi__DMatrix__zz_erfinv (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_exp" c_casadi__DMatrix__zz_exp - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_exp - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_exp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_exp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_exp :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_exp x = casadi__DMatrix__zz_exp (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_expand" c_casadi__DMatrix__zz_expand - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () -casadi__DMatrix__zz_expand - :: DMatrix -> DMatrix -> DMatrix -> IO () -casadi__DMatrix__zz_expand x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_expand errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_expand :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO () -dmatrix_zz_expand x = casadi__DMatrix__zz_expand (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_extractShared__0" c_casadi__DMatrix__zz_extractShared__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO () -casadi__DMatrix__zz_extractShared__0 - :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO () -casadi__DMatrix__zz_extractShared__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_extractShared__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_extractShared__0 :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO () -dmatrix_zz_extractShared__0 = casadi__DMatrix__zz_extractShared__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_extractShared__1" c_casadi__DMatrix__zz_extractShared__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO () -casadi__DMatrix__zz_extractShared__1 - :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> IO () -casadi__DMatrix__zz_extractShared__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_extractShared__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_extractShared__1 :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> IO () -dmatrix_zz_extractShared__1 = casadi__DMatrix__zz_extractShared__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_extractShared__2" c_casadi__DMatrix__zz_extractShared__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO () -casadi__DMatrix__zz_extractShared__2 - :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> String -> IO () -casadi__DMatrix__zz_extractShared__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_extractShared__2 :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> String -> IO () -dmatrix_zz_extractShared__2 = casadi__DMatrix__zz_extractShared__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_floor" c_casadi__DMatrix__zz_floor - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_floor - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_floor x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_floor errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_floor :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_floor x = casadi__DMatrix__zz_floor (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_gauss_quadrature__0" c_casadi__DMatrix__zz_gauss_quadrature__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_gauss_quadrature__0 - :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> Int -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_gauss_quadrature__0 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_gauss_quadrature__0 :: DMatrixClass a => a -> DMatrix -> DMatrix -> DMatrix -> Int -> DMatrix -> IO DMatrix -dmatrix_zz_gauss_quadrature__0 x = casadi__DMatrix__zz_gauss_quadrature__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_gauss_quadrature__1" c_casadi__DMatrix__zz_gauss_quadrature__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_gauss_quadrature__1 - :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_gauss_quadrature__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_gauss_quadrature__1 :: DMatrixClass a => a -> DMatrix -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_gauss_quadrature__1 x = casadi__DMatrix__zz_gauss_quadrature__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_gauss_quadrature__2" c_casadi__DMatrix__zz_gauss_quadrature__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_gauss_quadrature__2 - :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix -casadi__DMatrix__zz_gauss_quadrature__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_gauss_quadrature__2 :: DMatrixClass a => a -> DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix -dmatrix_zz_gauss_quadrature__2 x = casadi__DMatrix__zz_gauss_quadrature__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_ge" c_casadi__DMatrix__zz_ge - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_ge - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_ge x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_ge errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_ge :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_ge x = casadi__DMatrix__zz_ge (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_getMinor" c_casadi__DMatrix__zz_getMinor - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_getMinor - :: DMatrix -> Int -> Int -> IO DMatrix -casadi__DMatrix__zz_getMinor x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_getMinor errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_getMinor :: DMatrixClass a => a -> Int -> Int -> IO DMatrix -dmatrix_zz_getMinor x = casadi__DMatrix__zz_getMinor (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_getOperatorRepresentation" c_casadi__DMatrix__zz_getOperatorRepresentation - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) -casadi__DMatrix__zz_getOperatorRepresentation - :: DMatrix -> Vector String -> IO String -casadi__DMatrix__zz_getOperatorRepresentation x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_getOperatorRepresentation errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_getOperatorRepresentation :: DMatrixClass a => a -> Vector String -> IO String -dmatrix_zz_getOperatorRepresentation x = casadi__DMatrix__zz_getOperatorRepresentation (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_getSymbols__0" c_casadi__DMatrix__zz_getSymbols__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__zz_getSymbols__0 - :: Vector DMatrix -> IO (Vector DMatrix) -casadi__DMatrix__zz_getSymbols__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_getSymbols__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_getSymbols__0 :: Vector DMatrix -> IO (Vector DMatrix) -dmatrix_zz_getSymbols__0 = casadi__DMatrix__zz_getSymbols__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_getSymbols__1" c_casadi__DMatrix__zz_getSymbols__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__zz_getSymbols__1 - :: DMatrix -> IO (Vector DMatrix) -casadi__DMatrix__zz_getSymbols__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_getSymbols__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_getSymbols__1 :: DMatrixClass a => a -> IO (Vector DMatrix) -dmatrix_zz_getSymbols__1 x = casadi__DMatrix__zz_getSymbols__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_gradient" c_casadi__DMatrix__zz_gradient - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_gradient - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_gradient x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_gradient errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_gradient :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_gradient x = casadi__DMatrix__zz_gradient (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_gt" c_casadi__DMatrix__zz_gt - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_gt - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_gt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_gt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_gt :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_gt x = casadi__DMatrix__zz_gt (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_heaviside" c_casadi__DMatrix__zz_heaviside - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_heaviside - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_heaviside x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_heaviside errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_heaviside :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_heaviside x = casadi__DMatrix__zz_heaviside (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_hessian__0" c_casadi__DMatrix__zz_hessian__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () -casadi__DMatrix__zz_hessian__0 - :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> IO () -casadi__DMatrix__zz_hessian__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_hessian__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_hessian__0 :: DMatrixClass a => a -> DMatrix -> DMatrix -> DMatrix -> IO () -dmatrix_zz_hessian__0 x = casadi__DMatrix__zz_hessian__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_hessian__1" c_casadi__DMatrix__zz_hessian__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_hessian__1 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_hessian__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_hessian__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_hessian__1 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_hessian__1 x = casadi__DMatrix__zz_hessian__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_horzcat" c_casadi__DMatrix__zz_horzcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') -casadi__DMatrix__zz_horzcat - :: Vector DMatrix -> IO DMatrix -casadi__DMatrix__zz_horzcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_horzcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_horzcat :: Vector DMatrix -> IO DMatrix -dmatrix_zz_horzcat = casadi__DMatrix__zz_horzcat - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_horzsplit" c_casadi__DMatrix__zz_horzsplit - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__zz_horzsplit - :: DMatrix -> Vector Int -> IO (Vector DMatrix) -casadi__DMatrix__zz_horzsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_horzsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_horzsplit :: DMatrixClass a => a -> Vector Int -> IO (Vector DMatrix) -dmatrix_zz_horzsplit x = casadi__DMatrix__zz_horzsplit (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_if_else" c_casadi__DMatrix__zz_if_else - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_if_else - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_if_else x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_if_else errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_if_else :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_if_else x = casadi__DMatrix__zz_if_else (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_if_else_zero" c_casadi__DMatrix__zz_if_else_zero - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_if_else_zero - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_if_else_zero x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_if_else_zero errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_if_else_zero :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_if_else_zero x = casadi__DMatrix__zz_if_else_zero (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_inner_prod" c_casadi__DMatrix__zz_inner_prod - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_inner_prod - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_inner_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_inner_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_inner_prod :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_inner_prod x = casadi__DMatrix__zz_inner_prod (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_inv" c_casadi__DMatrix__zz_inv - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_inv - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_inv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_inv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_inv :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_inv x = casadi__DMatrix__zz_inv (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_isEqual__0" c_casadi__DMatrix__zz_isEqual__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__zz_isEqual__0 - :: DMatrix -> DMatrix -> IO Bool -casadi__DMatrix__zz_isEqual__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_isEqual__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_isEqual__0 :: DMatrixClass a => a -> DMatrix -> IO Bool -dmatrix_zz_isEqual__0 x = casadi__DMatrix__zz_isEqual__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_isEqual__1" c_casadi__DMatrix__zz_isEqual__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO CInt -casadi__DMatrix__zz_isEqual__1 - :: DMatrix -> DMatrix -> Int -> IO Bool -casadi__DMatrix__zz_isEqual__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_isEqual__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_isEqual__1 :: DMatrixClass a => a -> DMatrix -> Int -> IO Bool -dmatrix_zz_isEqual__1 x = casadi__DMatrix__zz_isEqual__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_jacobian" c_casadi__DMatrix__zz_jacobian - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_jacobian - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_jacobian x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_jacobian errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_jacobian :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_jacobian x = casadi__DMatrix__zz_jacobian (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_jacobianTimesVector__0" c_casadi__DMatrix__zz_jacobianTimesVector__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_jacobianTimesVector__0 - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_jacobianTimesVector__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_jacobianTimesVector__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_jacobianTimesVector__0 :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_jacobianTimesVector__0 x = casadi__DMatrix__zz_jacobianTimesVector__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_jacobianTimesVector__1" c_casadi__DMatrix__zz_jacobianTimesVector__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_jacobianTimesVector__1 - :: DMatrix -> DMatrix -> DMatrix -> Bool -> IO DMatrix -casadi__DMatrix__zz_jacobianTimesVector__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_jacobianTimesVector__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_jacobianTimesVector__1 :: DMatrixClass a => a -> DMatrix -> DMatrix -> Bool -> IO DMatrix -dmatrix_zz_jacobianTimesVector__1 x = casadi__DMatrix__zz_jacobianTimesVector__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_kron" c_casadi__DMatrix__zz_kron - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_kron - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_kron x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_kron errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_kron :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_kron x = casadi__DMatrix__zz_kron (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_le" c_casadi__DMatrix__zz_le - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_le - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_le x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_le errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_le :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_le x = casadi__DMatrix__zz_le (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_linspace" c_casadi__DMatrix__zz_linspace - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_linspace - :: DMatrix -> DMatrix -> Int -> IO DMatrix -casadi__DMatrix__zz_linspace x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_linspace errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_linspace :: DMatrixClass a => a -> DMatrix -> Int -> IO DMatrix -dmatrix_zz_linspace x = casadi__DMatrix__zz_linspace (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_log" c_casadi__DMatrix__zz_log - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_log - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_log x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_log errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_log :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_log x = casadi__DMatrix__zz_log (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_log10" c_casadi__DMatrix__zz_log10 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_log10 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_log10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_log10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_log10 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_log10 x = casadi__DMatrix__zz_log10 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_lt" c_casadi__DMatrix__zz_lt - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_lt - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_lt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_lt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_lt :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_lt x = casadi__DMatrix__zz_lt (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_max" c_casadi__DMatrix__zz_max - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_max - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_max x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_max errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_max :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_max x = casadi__DMatrix__zz_max (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_min" c_casadi__DMatrix__zz_min - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_min - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_min x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_min errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_min :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_min x = casadi__DMatrix__zz_min (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_minus" c_casadi__DMatrix__zz_minus - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_minus - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_minus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_minus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_minus :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_minus x = casadi__DMatrix__zz_minus (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_mod" c_casadi__DMatrix__zz_mod - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_mod - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_mod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_mod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_mod :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_mod x = casadi__DMatrix__zz_mod (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_mpower" c_casadi__DMatrix__zz_mpower - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_mpower - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_mpower x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_mpower errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_mpower :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_mpower x = casadi__DMatrix__zz_mpower (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_mtaylor__0" c_casadi__DMatrix__zz_mtaylor__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr DMatrix') -casadi__DMatrix__zz_mtaylor__0 - :: DMatrix -> DMatrix -> DMatrix -> Int -> Vector Int -> IO DMatrix -casadi__DMatrix__zz_mtaylor__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_mtaylor__0 :: DMatrixClass a => a -> DMatrix -> DMatrix -> Int -> Vector Int -> IO DMatrix -dmatrix_zz_mtaylor__0 x = casadi__DMatrix__zz_mtaylor__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_mtaylor__1" c_casadi__DMatrix__zz_mtaylor__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_mtaylor__1 - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_mtaylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_mtaylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_mtaylor__1 :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_mtaylor__1 x = casadi__DMatrix__zz_mtaylor__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_mtaylor__2" c_casadi__DMatrix__zz_mtaylor__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_mtaylor__2 - :: DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix -casadi__DMatrix__zz_mtaylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_mtaylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_mtaylor__2 :: DMatrixClass a => a -> DMatrix -> DMatrix -> Int -> IO DMatrix -dmatrix_zz_mtaylor__2 x = casadi__DMatrix__zz_mtaylor__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_mtimes__0" c_casadi__DMatrix__zz_mtimes__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_mtimes__0 - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_mtimes__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_mtimes__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_mtimes__0 :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_mtimes__0 x = casadi__DMatrix__zz_mtimes__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_mtimes__1" c_casadi__DMatrix__zz_mtimes__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_mtimes__1 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_mtimes__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_mtimes__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_mtimes__1 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_mtimes__1 x = casadi__DMatrix__zz_mtimes__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_ne" c_casadi__DMatrix__zz_ne - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_ne - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_ne x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_ne errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_ne :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_ne x = casadi__DMatrix__zz_ne (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_norm_0_mul" c_casadi__DMatrix__zz_norm_0_mul - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__zz_norm_0_mul - :: DMatrix -> DMatrix -> IO Int -casadi__DMatrix__zz_norm_0_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_norm_0_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_norm_0_mul :: DMatrixClass a => a -> DMatrix -> IO Int -dmatrix_zz_norm_0_mul x = casadi__DMatrix__zz_norm_0_mul (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_norm_1" c_casadi__DMatrix__zz_norm_1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_norm_1 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_norm_1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_norm_1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_norm_1 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_norm_1 x = casadi__DMatrix__zz_norm_1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_norm_2" c_casadi__DMatrix__zz_norm_2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_norm_2 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_norm_2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_norm_2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_norm_2 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_norm_2 x = casadi__DMatrix__zz_norm_2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_norm_F" c_casadi__DMatrix__zz_norm_F - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_norm_F - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_norm_F x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_norm_F errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_norm_F :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_norm_F x = casadi__DMatrix__zz_norm_F (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_norm_inf" c_casadi__DMatrix__zz_norm_inf - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_norm_inf - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_norm_inf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_norm_inf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_norm_inf :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_norm_inf x = casadi__DMatrix__zz_norm_inf (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_norm_inf_mul" c_casadi__DMatrix__zz_norm_inf_mul - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_norm_inf_mul - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_norm_inf_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_norm_inf_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_norm_inf_mul :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_norm_inf_mul x = casadi__DMatrix__zz_norm_inf_mul (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_not" c_casadi__DMatrix__zz_not - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_not - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_not x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_not errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_not :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_not x = casadi__DMatrix__zz_not (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_nullspace" c_casadi__DMatrix__zz_nullspace - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_nullspace - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_nullspace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_nullspace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_nullspace :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_nullspace x = casadi__DMatrix__zz_nullspace (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_or" c_casadi__DMatrix__zz_or - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_or - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_or x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_or errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_or :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_or x = casadi__DMatrix__zz_or (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_outer_prod" c_casadi__DMatrix__zz_outer_prod - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_outer_prod - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_outer_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_outer_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_outer_prod :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_outer_prod x = casadi__DMatrix__zz_outer_prod (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_pinv" c_casadi__DMatrix__zz_pinv - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_pinv - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_pinv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_pinv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_pinv :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_pinv x = casadi__DMatrix__zz_pinv (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_plus" c_casadi__DMatrix__zz_plus - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_plus - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_plus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_plus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_plus :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_plus x = casadi__DMatrix__zz_plus (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_poly_coeff" c_casadi__DMatrix__zz_poly_coeff - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_poly_coeff - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_poly_coeff x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_poly_coeff errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_poly_coeff :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_poly_coeff x = casadi__DMatrix__zz_poly_coeff (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_poly_roots" c_casadi__DMatrix__zz_poly_roots - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_poly_roots - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_poly_roots x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_poly_roots errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_poly_roots :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_poly_roots x = casadi__DMatrix__zz_poly_roots (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_polyval" c_casadi__DMatrix__zz_polyval - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_polyval - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_polyval x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_polyval errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_polyval :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_polyval x = casadi__DMatrix__zz_polyval (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_power" c_casadi__DMatrix__zz_power - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_power - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_power x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_power errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_power :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_power x = casadi__DMatrix__zz_power (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_printCompact" c_casadi__DMatrix__zz_printCompact - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () -casadi__DMatrix__zz_printCompact - :: DMatrix -> IO () -casadi__DMatrix__zz_printCompact x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_printCompact errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_printCompact :: DMatrixClass a => a -> IO () -dmatrix_zz_printCompact x = casadi__DMatrix__zz_printCompact (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_project" c_casadi__DMatrix__zz_project - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_project - :: DMatrix -> Sparsity -> IO DMatrix -casadi__DMatrix__zz_project x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_project errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_project :: DMatrixClass a => a -> Sparsity -> IO DMatrix -dmatrix_zz_project x = casadi__DMatrix__zz_project (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_pw_const" c_casadi__DMatrix__zz_pw_const - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_pw_const - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_pw_const x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_pw_const errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_pw_const :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_pw_const x = casadi__DMatrix__zz_pw_const (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_pw_lin" c_casadi__DMatrix__zz_pw_lin - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_pw_lin - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_pw_lin x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_pw_lin errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_pw_lin :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_pw_lin x = casadi__DMatrix__zz_pw_lin (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_qr" c_casadi__DMatrix__zz_qr - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () -casadi__DMatrix__zz_qr - :: DMatrix -> DMatrix -> DMatrix -> IO () -casadi__DMatrix__zz_qr x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_qr errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_qr :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO () -dmatrix_zz_qr x = casadi__DMatrix__zz_qr (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_quad_form__0" c_casadi__DMatrix__zz_quad_form__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_quad_form__0 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_quad_form__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_quad_form__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_quad_form__0 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_quad_form__0 x = casadi__DMatrix__zz_quad_form__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_quad_form__1" c_casadi__DMatrix__zz_quad_form__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_quad_form__1 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_quad_form__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_quad_form__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_quad_form__1 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_quad_form__1 x = casadi__DMatrix__zz_quad_form__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_quad_form__2" c_casadi__DMatrix__zz_quad_form__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_quad_form__2 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_quad_form__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_quad_form__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_quad_form__2 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_quad_form__2 x = casadi__DMatrix__zz_quad_form__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_quad_form__3" c_casadi__DMatrix__zz_quad_form__3 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_quad_form__3 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_quad_form__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_quad_form__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_quad_form__3 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_quad_form__3 x = casadi__DMatrix__zz_quad_form__3 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_ramp" c_casadi__DMatrix__zz_ramp - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_ramp - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_ramp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_ramp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_ramp :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_ramp x = casadi__DMatrix__zz_ramp (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_rdivide" c_casadi__DMatrix__zz_rdivide - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_rdivide - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_rdivide x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_rdivide errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_rdivide :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_rdivide x = casadi__DMatrix__zz_rdivide (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_rectangle" c_casadi__DMatrix__zz_rectangle - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_rectangle - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_rectangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_rectangle errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_rectangle :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_rectangle x = casadi__DMatrix__zz_rectangle (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_repmat__0" c_casadi__DMatrix__zz_repmat__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_repmat__0 - :: DMatrix -> Int -> IO DMatrix -casadi__DMatrix__zz_repmat__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_repmat__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_repmat__0 :: DMatrixClass a => a -> Int -> IO DMatrix -dmatrix_zz_repmat__0 x = casadi__DMatrix__zz_repmat__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_repmat__1" c_casadi__DMatrix__zz_repmat__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_repmat__1 - :: DMatrix -> Int -> Int -> IO DMatrix -casadi__DMatrix__zz_repmat__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_repmat__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_repmat__1 :: DMatrixClass a => a -> Int -> Int -> IO DMatrix -dmatrix_zz_repmat__1 x = casadi__DMatrix__zz_repmat__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_reshape__0" c_casadi__DMatrix__zz_reshape__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_reshape__0 - :: DMatrix -> Sparsity -> IO DMatrix -casadi__DMatrix__zz_reshape__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_reshape__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_reshape__0 :: DMatrixClass a => a -> Sparsity -> IO DMatrix -dmatrix_zz_reshape__0 x = casadi__DMatrix__zz_reshape__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_reshape__1" c_casadi__DMatrix__zz_reshape__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_reshape__1 - :: DMatrix -> Int -> Int -> IO DMatrix -casadi__DMatrix__zz_reshape__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_reshape__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_reshape__1 :: DMatrixClass a => a -> Int -> Int -> IO DMatrix -dmatrix_zz_reshape__1 x = casadi__DMatrix__zz_reshape__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sign" c_casadi__DMatrix__zz_sign - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sign - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sign x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sign errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sign :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sign x = casadi__DMatrix__zz_sign (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_simplify" c_casadi__DMatrix__zz_simplify - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_simplify - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_simplify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_simplify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_simplify :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_simplify x = casadi__DMatrix__zz_simplify (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sin" c_casadi__DMatrix__zz_sin - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sin - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sin :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sin x = casadi__DMatrix__zz_sin (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sinh" c_casadi__DMatrix__zz_sinh - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sinh - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sinh :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sinh x = casadi__DMatrix__zz_sinh (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_solve" c_casadi__DMatrix__zz_solve - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_solve - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_solve x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_solve errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_solve :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_solve x = casadi__DMatrix__zz_solve (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sparsify__0" c_casadi__DMatrix__zz_sparsify__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sparsify__0 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sparsify__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sparsify__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sparsify__0 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sparsify__0 x = casadi__DMatrix__zz_sparsify__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sparsify__1" c_casadi__DMatrix__zz_sparsify__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sparsify__1 - :: DMatrix -> Double -> IO DMatrix -casadi__DMatrix__zz_sparsify__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sparsify__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sparsify__1 :: DMatrixClass a => a -> Double -> IO DMatrix -dmatrix_zz_sparsify__1 x = casadi__DMatrix__zz_sparsify__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sprank" c_casadi__DMatrix__zz_sprank - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt -casadi__DMatrix__zz_sprank - :: DMatrix -> IO Int -casadi__DMatrix__zz_sprank x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sprank errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sprank :: DMatrixClass a => a -> IO Int -dmatrix_zz_sprank x = casadi__DMatrix__zz_sprank (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_spy" c_casadi__DMatrix__zz_spy - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_spy - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_spy x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_spy errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_spy :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_spy x = casadi__DMatrix__zz_spy (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sqrt" c_casadi__DMatrix__zz_sqrt - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sqrt - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sqrt x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sqrt errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sqrt :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sqrt x = casadi__DMatrix__zz_sqrt (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_substitute__0" c_casadi__DMatrix__zz_substitute__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__zz_substitute__0 - :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO (Vector DMatrix) -casadi__DMatrix__zz_substitute__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_substitute__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_substitute__0 :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO (Vector DMatrix) -dmatrix_zz_substitute__0 = casadi__DMatrix__zz_substitute__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_substitute__1" c_casadi__DMatrix__zz_substitute__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_substitute__1 - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_substitute__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_substitute__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_substitute__1 :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_substitute__1 x = casadi__DMatrix__zz_substitute__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_substituteInPlace__0" c_casadi__DMatrix__zz_substituteInPlace__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO () -casadi__DMatrix__zz_substituteInPlace__0 - :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO () -casadi__DMatrix__zz_substituteInPlace__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_substituteInPlace__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_substituteInPlace__0 :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO () -dmatrix_zz_substituteInPlace__0 = casadi__DMatrix__zz_substituteInPlace__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_substituteInPlace__1" c_casadi__DMatrix__zz_substituteInPlace__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO () -casadi__DMatrix__zz_substituteInPlace__1 - :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () -casadi__DMatrix__zz_substituteInPlace__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_substituteInPlace__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_substituteInPlace__1 :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () -dmatrix_zz_substituteInPlace__1 = casadi__DMatrix__zz_substituteInPlace__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sumAll" c_casadi__DMatrix__zz_sumAll - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sumAll - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sumAll x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sumAll errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sumAll :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sumAll x = casadi__DMatrix__zz_sumAll (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sumCols" c_casadi__DMatrix__zz_sumCols - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sumCols - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sumCols x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sumCols errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sumCols :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sumCols x = casadi__DMatrix__zz_sumCols (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sumRows" c_casadi__DMatrix__zz_sumRows - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sumRows - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sumRows x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sumRows errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sumRows :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sumRows x = casadi__DMatrix__zz_sumRows (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_sum_square" c_casadi__DMatrix__zz_sum_square - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_sum_square - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_sum_square x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_sum_square errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_sum_square :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_sum_square x = casadi__DMatrix__zz_sum_square (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_tan" c_casadi__DMatrix__zz_tan - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_tan - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_tan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_tan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_tan :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_tan x = casadi__DMatrix__zz_tan (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_tangent" c_casadi__DMatrix__zz_tangent - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_tangent - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_tangent x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_tangent errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_tangent :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_tangent x = casadi__DMatrix__zz_tangent (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_tanh" c_casadi__DMatrix__zz_tanh - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_tanh - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_tanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_tanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_tanh :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_tanh x = casadi__DMatrix__zz_tanh (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_taylor__0" c_casadi__DMatrix__zz_taylor__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_taylor__0 - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_taylor__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_taylor__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_taylor__0 :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_taylor__0 x = casadi__DMatrix__zz_taylor__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_taylor__1" c_casadi__DMatrix__zz_taylor__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_taylor__1 - :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_taylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_taylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_taylor__1 :: DMatrixClass a => a -> DMatrix -> DMatrix -> IO DMatrix -dmatrix_zz_taylor__1 x = casadi__DMatrix__zz_taylor__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_taylor__2" c_casadi__DMatrix__zz_taylor__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_taylor__2 - :: DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix -casadi__DMatrix__zz_taylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_taylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_taylor__2 :: DMatrixClass a => a -> DMatrix -> DMatrix -> Int -> IO DMatrix -dmatrix_zz_taylor__2 x = casadi__DMatrix__zz_taylor__2 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_times" c_casadi__DMatrix__zz_times - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_times - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_times x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_times errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_times :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_times x = casadi__DMatrix__zz_times (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_trace" c_casadi__DMatrix__zz_trace - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_trace - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_trace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_trace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_trace :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_trace x = casadi__DMatrix__zz_trace (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_triangle" c_casadi__DMatrix__zz_triangle - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_triangle - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_triangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_triangle errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_triangle :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_triangle x = casadi__DMatrix__zz_triangle (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_tril__0" c_casadi__DMatrix__zz_tril__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_tril__0 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_tril__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_tril__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_tril__0 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_tril__0 x = casadi__DMatrix__zz_tril__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_tril__1" c_casadi__DMatrix__zz_tril__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_tril__1 - :: DMatrix -> Bool -> IO DMatrix -casadi__DMatrix__zz_tril__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_tril__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_tril__1 :: DMatrixClass a => a -> Bool -> IO DMatrix -dmatrix_zz_tril__1 x = casadi__DMatrix__zz_tril__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_tril2symm" c_casadi__DMatrix__zz_tril2symm - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_tril2symm - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_tril2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_tril2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_tril2symm :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_tril2symm x = casadi__DMatrix__zz_tril2symm (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_triu__0" c_casadi__DMatrix__zz_triu__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_triu__0 - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_triu__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_triu__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_triu__0 :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_triu__0 x = casadi__DMatrix__zz_triu__0 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_triu__1" c_casadi__DMatrix__zz_triu__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') -casadi__DMatrix__zz_triu__1 - :: DMatrix -> Bool -> IO DMatrix -casadi__DMatrix__zz_triu__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_triu__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_triu__1 :: DMatrixClass a => a -> Bool -> IO DMatrix -dmatrix_zz_triu__1 x = casadi__DMatrix__zz_triu__1 (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_triu2symm" c_casadi__DMatrix__zz_triu2symm - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_triu2symm - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_triu2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_triu2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_triu2symm :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_triu2symm x = casadi__DMatrix__zz_triu2symm (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_unite" c_casadi__DMatrix__zz_unite - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_unite - :: DMatrix -> DMatrix -> IO DMatrix -casadi__DMatrix__zz_unite x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_unite errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_unite :: DMatrixClass a => a -> DMatrix -> IO DMatrix -dmatrix_zz_unite x = casadi__DMatrix__zz_unite (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_vec" c_casadi__DMatrix__zz_vec - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_vec - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_vec x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_vec errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_vec :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_vec x = casadi__DMatrix__zz_vec (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_vecNZ" c_casadi__DMatrix__zz_vecNZ - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -casadi__DMatrix__zz_vecNZ - :: DMatrix -> IO DMatrix -casadi__DMatrix__zz_vecNZ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_vecNZ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_vecNZ :: DMatrixClass a => a -> IO DMatrix -dmatrix_zz_vecNZ x = casadi__DMatrix__zz_vecNZ (castDMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_vecNZcat" c_casadi__DMatrix__zz_vecNZcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') -casadi__DMatrix__zz_vecNZcat - :: Vector DMatrix -> IO DMatrix -casadi__DMatrix__zz_vecNZcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_vecNZcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_vecNZcat :: Vector DMatrix -> IO DMatrix -dmatrix_zz_vecNZcat = casadi__DMatrix__zz_vecNZcat - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_veccat" c_casadi__DMatrix__zz_veccat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') -casadi__DMatrix__zz_veccat - :: Vector DMatrix -> IO DMatrix -casadi__DMatrix__zz_veccat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_veccat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_veccat :: Vector DMatrix -> IO DMatrix -dmatrix_zz_veccat = casadi__DMatrix__zz_veccat - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_vertcat" c_casadi__DMatrix__zz_vertcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') -casadi__DMatrix__zz_vertcat - :: Vector DMatrix -> IO DMatrix -casadi__DMatrix__zz_vertcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_vertcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_vertcat :: Vector DMatrix -> IO DMatrix -dmatrix_zz_vertcat = casadi__DMatrix__zz_vertcat - - --- direct wrapper -foreign import ccall unsafe "casadi__DMatrix__zz_vertsplit" c_casadi__DMatrix__zz_vertsplit - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__DMatrix__zz_vertsplit - :: DMatrix -> Vector Int -> IO (Vector DMatrix) -casadi__DMatrix__zz_vertsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__DMatrix__zz_vertsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -dmatrix_zz_vertsplit :: DMatrixClass a => a -> Vector Int -> IO (Vector DMatrix) -dmatrix_zz_vertsplit x = casadi__DMatrix__zz_vertsplit (castDMatrix x) + dmatrix___nonzero__, + dmatrix_append, + dmatrix_appendColumns, + dmatrix_binary, + dmatrix_className, + dmatrix_clear, + dmatrix_colind, + dmatrix_dimString, + dmatrix_enlarge__0, + dmatrix_enlarge__1, + dmatrix_erase__0, + dmatrix_erase__1, + dmatrix_erase__2, + dmatrix_erase__3, + dmatrix_eye, + dmatrix_find__0, + dmatrix_find__1, + dmatrix_getColind, + dmatrix_getDep__0, + dmatrix_getDep__1, + dmatrix_getDescription, + dmatrix_getElementHash, + dmatrix_getEqualityCheckingDepth, + dmatrix_getIntValue, + dmatrix_getNZ__0, + dmatrix_getNZ__1, + dmatrix_getNZ__2, + dmatrix_getName, + dmatrix_getNdeps, + dmatrix_getRepresentation, + dmatrix_getRow, + dmatrix_getSparsity, + dmatrix_getSym, + dmatrix_getValue__0, + dmatrix_getValue__1, + dmatrix_get__0, + dmatrix_get__1, + dmatrix_get__2, + dmatrix_get__3, + dmatrix_get__4, + dmatrix_get__5, + dmatrix_get__6, + dmatrix_get__7, + dmatrix_hasDuplicates, + dmatrix_hasNZ, + dmatrix_hasNonStructuralZeros, + dmatrix_inf__0, + dmatrix_inf__1, + dmatrix_inf__2, + dmatrix_inf__3, + dmatrix_inf__4, + dmatrix_isCommutative, + dmatrix_isConstant, + dmatrix_isIdentity, + dmatrix_isInteger, + dmatrix_isLeaf, + dmatrix_isMinusOne, + dmatrix_isOne, + dmatrix_isRegular, + dmatrix_isSlice__0, + dmatrix_isSlice__1, + dmatrix_isSmooth, + dmatrix_isSymbolic, + dmatrix_isValidInput, + dmatrix_isZero, + dmatrix_iscolumn, + dmatrix_isdense, + dmatrix_isempty__0, + dmatrix_isempty__1, + dmatrix_isrow, + dmatrix_isscalar__0, + dmatrix_isscalar__1, + dmatrix_issquare, + dmatrix_istril, + dmatrix_istriu, + dmatrix_isvector, + dmatrix_makeSparse__0, + dmatrix_makeSparse__1, + dmatrix_matrix_matrix, + dmatrix_matrix_scalar, + dmatrix_nan__0, + dmatrix_nan__1, + dmatrix_nan__2, + dmatrix_nan__3, + dmatrix_nan__4, + dmatrix_nnz, + dmatrix_nonzeros, + dmatrix_nonzeros_int, + dmatrix_numel__0, + dmatrix_numel__1, + dmatrix_ones__0, + dmatrix_ones__1, + dmatrix_ones__2, + dmatrix_ones__3, + dmatrix_ones__4, + dmatrix_operator_minus, + dmatrix_operator_plus, + dmatrix_printDense, + dmatrix_printScalar, + dmatrix_printSparse, + dmatrix_printSplit, + dmatrix_printVector, + dmatrix_printme, + dmatrix_remove, + dmatrix_reserve__0, + dmatrix_reserve__1, + dmatrix_resetInput, + dmatrix_resize, + dmatrix_row, + dmatrix_sanityCheck__0, + dmatrix_sanityCheck__1, + dmatrix_scalar_matrix, + dmatrix_setEqualityCheckingDepth__0, + dmatrix_setEqualityCheckingDepth__1, + dmatrix_setNZ__0, + dmatrix_setNZ__1, + dmatrix_setNZ__2, + dmatrix_setNZ__3, + dmatrix_setPrecision, + dmatrix_setScientific, + dmatrix_setSym, + dmatrix_setValue__0, + dmatrix_setValue__1, + dmatrix_setWidth, + dmatrix_setZero, + dmatrix_set__0, + dmatrix_set__1, + dmatrix_set__10, + dmatrix_set__2, + dmatrix_set__3, + dmatrix_set__4, + dmatrix_set__5, + dmatrix_set__6, + dmatrix_set__7, + dmatrix_set__8, + dmatrix_set__9, + dmatrix_shape__0, + dmatrix_shape__1, + dmatrix_size, + dmatrix_size1, + dmatrix_size2, + dmatrix_sizeD, + dmatrix_sizeL, + dmatrix_sizeU, + dmatrix_sparse__0, + dmatrix_sparse__1, + dmatrix_sparse__2, + dmatrix_sparse__3, + dmatrix_sparse__4, + dmatrix_sparsity, + dmatrix_sym__0, + dmatrix_sym__1, + dmatrix_sym__2, + dmatrix_sym__3, + dmatrix_sym__4, + dmatrix_sym__5, + dmatrix_sym__6, + dmatrix_sym__7, + dmatrix_sym__8, + dmatrix_toSlice__0, + dmatrix_toSlice__1, + dmatrix_triplet__0, + dmatrix_triplet__1, + dmatrix_triplet__2, + dmatrix_unary, + dmatrix_zeros__0, + dmatrix_zeros__1, + dmatrix_zeros__2, + dmatrix_zeros__3, + dmatrix_zeros__4, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__0" c_casadi__DMatrix__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__0 + :: Vector Int -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__0 :: Vector Int -> IO DMatrix +dmatrix__0 = casadi__DMatrix__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__1" c_casadi__DMatrix__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__1 + :: IMatrix -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__1 :: IMatrix -> IO DMatrix +dmatrix__1 = casadi__DMatrix__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__2" c_casadi__DMatrix__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__2 + :: Vector (Vector Double) -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__2 :: Vector (Vector Double) -> IO DMatrix +dmatrix__2 = casadi__DMatrix__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__3" c_casadi__DMatrix__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__3 + :: Double -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__3 :: Double -> IO DMatrix +dmatrix__3 = casadi__DMatrix__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__4" c_casadi__DMatrix__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__4 + :: Sparsity -> DMatrix -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__4 :: Sparsity -> DMatrix -> IO DMatrix +dmatrix__4 = casadi__DMatrix__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__5" c_casadi__DMatrix__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__5 + :: Sparsity -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__5 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__5 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__5 :: Sparsity -> IO DMatrix +dmatrix__5 = casadi__DMatrix__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__6" c_casadi__DMatrix__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__6 + :: Int -> Int -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__6 :: Int -> Int -> IO DMatrix +dmatrix__6 = casadi__DMatrix__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__7" c_casadi__DMatrix__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__7 + :: DMatrix -> IO DMatrix +casadi__DMatrix__CONSTRUCTOR__7 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__7 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__7 :: DMatrix -> IO DMatrix +dmatrix__7 = casadi__DMatrix__CONSTRUCTOR__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__8" c_casadi__DMatrix__CONSTRUCTOR__8 + :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') +casadi__DMatrix__CONSTRUCTOR__8 + :: IO DMatrix +casadi__DMatrix__CONSTRUCTOR__8 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__CONSTRUCTOR__8 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix__8 :: IO DMatrix +dmatrix__8 = casadi__DMatrix__CONSTRUCTOR__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__T" c_casadi__DMatrix__T + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__T + :: DMatrix -> IO DMatrix +casadi__DMatrix__T x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__T errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_T :: DMatrixClass a => a -> IO DMatrix +dmatrix_T x = casadi__DMatrix__T (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix____nonzero__" c_casadi__DMatrix____nonzero__ + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix____nonzero__ + :: DMatrix -> IO Bool +casadi__DMatrix____nonzero__ x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix____nonzero__ errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix___nonzero__ :: DMatrixClass a => a -> IO Bool +dmatrix___nonzero__ x = casadi__DMatrix____nonzero__ (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__append" c_casadi__DMatrix__append + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO () +casadi__DMatrix__append + :: DMatrix -> DMatrix -> IO () +casadi__DMatrix__append x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__append errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_append :: DMatrixClass a => a -> DMatrix -> IO () +dmatrix_append x = casadi__DMatrix__append (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__appendColumns" c_casadi__DMatrix__appendColumns + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO () +casadi__DMatrix__appendColumns + :: DMatrix -> DMatrix -> IO () +casadi__DMatrix__appendColumns x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__appendColumns errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_appendColumns :: DMatrixClass a => a -> DMatrix -> IO () +dmatrix_appendColumns x = casadi__DMatrix__appendColumns (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__binary" c_casadi__DMatrix__binary + :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__binary + :: Int -> DMatrix -> DMatrix -> IO DMatrix +casadi__DMatrix__binary x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__binary errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_binary :: Int -> DMatrix -> DMatrix -> IO DMatrix +dmatrix_binary = casadi__DMatrix__binary + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__className" c_casadi__DMatrix__className + :: Ptr (Ptr StdString) -> IO (Ptr StdString) +casadi__DMatrix__className + :: IO String +casadi__DMatrix__className = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__className errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_className :: IO String +dmatrix_className = casadi__DMatrix__className + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__clear" c_casadi__DMatrix__clear + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__clear + :: DMatrix -> IO () +casadi__DMatrix__clear x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__clear errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_clear :: DMatrixClass a => a -> IO () +dmatrix_clear x = casadi__DMatrix__clear (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__colind" c_casadi__DMatrix__colind + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt +casadi__DMatrix__colind + :: DMatrix -> Int -> IO Int +casadi__DMatrix__colind x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__colind errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_colind :: DMatrixClass a => a -> Int -> IO Int +dmatrix_colind x = casadi__DMatrix__colind (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__dimString" c_casadi__DMatrix__dimString + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString) +casadi__DMatrix__dimString + :: DMatrix -> IO String +casadi__DMatrix__dimString x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__dimString errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_dimString :: DMatrixClass a => a -> IO String +dmatrix_dimString x = casadi__DMatrix__dimString (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__enlarge__0" c_casadi__DMatrix__enlarge__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__DMatrix__enlarge__0 + :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () +casadi__DMatrix__enlarge__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_enlarge__0 :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () +dmatrix_enlarge__0 x = casadi__DMatrix__enlarge__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__enlarge__1" c_casadi__DMatrix__enlarge__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__DMatrix__enlarge__1 + :: DMatrix -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +casadi__DMatrix__enlarge__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_enlarge__1 :: DMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +dmatrix_enlarge__1 x = casadi__DMatrix__enlarge__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__erase__0" c_casadi__DMatrix__erase__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO () +casadi__DMatrix__erase__0 + :: DMatrix -> Vector Int -> IO () +casadi__DMatrix__erase__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__erase__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_erase__0 :: DMatrixClass a => a -> Vector Int -> IO () +dmatrix_erase__0 x = casadi__DMatrix__erase__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__erase__1" c_casadi__DMatrix__erase__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__DMatrix__erase__1 + :: DMatrix -> Vector Int -> Bool -> IO () +casadi__DMatrix__erase__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__erase__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_erase__1 :: DMatrixClass a => a -> Vector Int -> Bool -> IO () +dmatrix_erase__1 x = casadi__DMatrix__erase__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__erase__2" c_casadi__DMatrix__erase__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__DMatrix__erase__2 + :: DMatrix -> Vector Int -> Vector Int -> IO () +casadi__DMatrix__erase__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__erase__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_erase__2 :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO () +dmatrix_erase__2 x = casadi__DMatrix__erase__2 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__erase__3" c_casadi__DMatrix__erase__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__DMatrix__erase__3 + :: DMatrix -> Vector Int -> Vector Int -> Bool -> IO () +casadi__DMatrix__erase__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__erase__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_erase__3 :: DMatrixClass a => a -> Vector Int -> Vector Int -> Bool -> IO () +dmatrix_erase__3 x = casadi__DMatrix__erase__3 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__eye" c_casadi__DMatrix__eye + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__eye + :: Int -> IO DMatrix +casadi__DMatrix__eye x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__eye errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_eye :: Int -> IO DMatrix +dmatrix_eye = casadi__DMatrix__eye + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__find__0" c_casadi__DMatrix__find__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) +casadi__DMatrix__find__0 + :: DMatrix -> IO (Vector Int) +casadi__DMatrix__find__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__find__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_find__0 :: DMatrixClass a => a -> IO (Vector Int) +dmatrix_find__0 x = casadi__DMatrix__find__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__find__1" c_casadi__DMatrix__find__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec CInt)) +casadi__DMatrix__find__1 + :: DMatrix -> Bool -> IO (Vector Int) +casadi__DMatrix__find__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__find__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_find__1 :: DMatrixClass a => a -> Bool -> IO (Vector Int) +dmatrix_find__1 x = casadi__DMatrix__find__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__0" c_casadi__DMatrix__get__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__DMatrix__get__0 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () +casadi__DMatrix__get__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () +dmatrix_get__0 x = casadi__DMatrix__get__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__1" c_casadi__DMatrix__get__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__DMatrix__get__1 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> Slice -> IO () +casadi__DMatrix__get__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__1 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> Slice -> IO () +dmatrix_get__1 x = casadi__DMatrix__get__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__2" c_casadi__DMatrix__get__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__DMatrix__get__2 + :: DMatrix -> DMatrix -> Bool -> Slice -> IMatrix -> IO () +casadi__DMatrix__get__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__2 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IMatrix -> IO () +dmatrix_get__2 x = casadi__DMatrix__get__2 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__3" c_casadi__DMatrix__get__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__DMatrix__get__3 + :: DMatrix -> DMatrix -> Bool -> Slice -> Slice -> IO () +casadi__DMatrix__get__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__3 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> Slice -> IO () +dmatrix_get__3 x = casadi__DMatrix__get__3 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__4" c_casadi__DMatrix__get__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Sparsity' -> IO () +casadi__DMatrix__get__4 + :: DMatrix -> DMatrix -> Bool -> Sparsity -> IO () +casadi__DMatrix__get__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__4 :: DMatrixClass a => a -> DMatrix -> Bool -> Sparsity -> IO () +dmatrix_get__4 x = casadi__DMatrix__get__4 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__5" c_casadi__DMatrix__get__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__DMatrix__get__5 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () +casadi__DMatrix__get__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__5 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () +dmatrix_get__5 x = casadi__DMatrix__get__5 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__6" c_casadi__DMatrix__get__6 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__DMatrix__get__6 + :: DMatrix -> DMatrix -> Bool -> Slice -> IO () +casadi__DMatrix__get__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__6 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () +dmatrix_get__6 x = casadi__DMatrix__get__6 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__get__7" c_casadi__DMatrix__get__7 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__DMatrix__get__7 + :: DMatrix -> Vector Double -> IO () +casadi__DMatrix__get__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__get__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_get__7 :: DMatrixClass a => a -> Vector Double -> IO () +dmatrix_get__7 x = casadi__DMatrix__get__7 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getColind" c_casadi__DMatrix__getColind + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) +casadi__DMatrix__getColind + :: DMatrix -> IO (Vector Int) +casadi__DMatrix__getColind x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getColind errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getColind :: DMatrixClass a => a -> IO (Vector Int) +dmatrix_getColind x = casadi__DMatrix__getColind (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getDep__0" c_casadi__DMatrix__getDep__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__getDep__0 + :: DMatrix -> IO DMatrix +casadi__DMatrix__getDep__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getDep__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getDep__0 :: DMatrixClass a => a -> IO DMatrix +dmatrix_getDep__0 x = casadi__DMatrix__getDep__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getDep__1" c_casadi__DMatrix__getDep__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__getDep__1 + :: DMatrix -> Int -> IO DMatrix +casadi__DMatrix__getDep__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getDep__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getDep__1 :: DMatrixClass a => a -> Int -> IO DMatrix +dmatrix_getDep__1 x = casadi__DMatrix__getDep__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getElementHash" c_casadi__DMatrix__getElementHash + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CSize +casadi__DMatrix__getElementHash + :: DMatrix -> IO CSize +casadi__DMatrix__getElementHash x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getElementHash errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getElementHash :: DMatrixClass a => a -> IO CSize +dmatrix_getElementHash x = casadi__DMatrix__getElementHash (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getEqualityCheckingDepth" c_casadi__DMatrix__getEqualityCheckingDepth + :: Ptr (Ptr StdString) -> IO CInt +casadi__DMatrix__getEqualityCheckingDepth + :: IO Int +casadi__DMatrix__getEqualityCheckingDepth = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getEqualityCheckingDepth errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getEqualityCheckingDepth :: IO Int +dmatrix_getEqualityCheckingDepth = casadi__DMatrix__getEqualityCheckingDepth + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getIntValue" c_casadi__DMatrix__getIntValue + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__getIntValue + :: DMatrix -> IO Int +casadi__DMatrix__getIntValue x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getIntValue errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getIntValue :: DMatrixClass a => a -> IO Int +dmatrix_getIntValue x = casadi__DMatrix__getIntValue (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getNZ__0" c_casadi__DMatrix__getNZ__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__DMatrix__getNZ__0 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () +casadi__DMatrix__getNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getNZ__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () +dmatrix_getNZ__0 x = casadi__DMatrix__getNZ__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getNZ__1" c_casadi__DMatrix__getNZ__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__DMatrix__getNZ__1 + :: DMatrix -> DMatrix -> Bool -> Slice -> IO () +casadi__DMatrix__getNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getNZ__1 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () +dmatrix_getNZ__1 x = casadi__DMatrix__getNZ__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getNZ__2" c_casadi__DMatrix__getNZ__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__DMatrix__getNZ__2 + :: DMatrix -> Vector Double -> IO () +casadi__DMatrix__getNZ__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getNZ__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getNZ__2 :: DMatrixClass a => a -> Vector Double -> IO () +dmatrix_getNZ__2 x = casadi__DMatrix__getNZ__2 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getName" c_casadi__DMatrix__getName + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr StdString) +casadi__DMatrix__getName + :: DMatrix -> IO String +casadi__DMatrix__getName x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getName errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getName :: DMatrixClass a => a -> IO String +dmatrix_getName x = casadi__DMatrix__getName (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getNdeps" c_casadi__DMatrix__getNdeps + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__getNdeps + :: DMatrix -> IO Int +casadi__DMatrix__getNdeps x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getNdeps errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getNdeps :: DMatrixClass a => a -> IO Int +dmatrix_getNdeps x = casadi__DMatrix__getNdeps (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getRow" c_casadi__DMatrix__getRow + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) +casadi__DMatrix__getRow + :: DMatrix -> IO (Vector Int) +casadi__DMatrix__getRow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getRow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getRow :: DMatrixClass a => a -> IO (Vector Int) +dmatrix_getRow x = casadi__DMatrix__getRow (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getSparsity" c_casadi__DMatrix__getSparsity + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Sparsity') +casadi__DMatrix__getSparsity + :: DMatrix -> IO Sparsity +casadi__DMatrix__getSparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getSparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getSparsity :: DMatrixClass a => a -> IO Sparsity +dmatrix_getSparsity x = casadi__DMatrix__getSparsity (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getSym" c_casadi__DMatrix__getSym + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__DMatrix__getSym + :: DMatrix -> Vector Double -> IO () +casadi__DMatrix__getSym x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getSym errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getSym :: DMatrixClass a => a -> Vector Double -> IO () +dmatrix_getSym x = casadi__DMatrix__getSym (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getValue__0" c_casadi__DMatrix__getValue__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CDouble +casadi__DMatrix__getValue__0 + :: DMatrix -> Int -> IO Double +casadi__DMatrix__getValue__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getValue__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getValue__0 :: DMatrixClass a => a -> Int -> IO Double +dmatrix_getValue__0 x = casadi__DMatrix__getValue__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__getValue__1" c_casadi__DMatrix__getValue__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CDouble +casadi__DMatrix__getValue__1 + :: DMatrix -> IO Double +casadi__DMatrix__getValue__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__getValue__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_getValue__1 :: DMatrixClass a => a -> IO Double +dmatrix_getValue__1 x = casadi__DMatrix__getValue__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__hasDuplicates" c_casadi__DMatrix__hasDuplicates + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__hasDuplicates + :: DMatrix -> IO Bool +casadi__DMatrix__hasDuplicates x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__hasDuplicates errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_hasDuplicates :: DMatrixClass a => a -> IO Bool +dmatrix_hasDuplicates x = casadi__DMatrix__hasDuplicates (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__hasNZ" c_casadi__DMatrix__hasNZ + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO CInt +casadi__DMatrix__hasNZ + :: DMatrix -> Int -> Int -> IO Bool +casadi__DMatrix__hasNZ x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__hasNZ errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_hasNZ :: DMatrixClass a => a -> Int -> Int -> IO Bool +dmatrix_hasNZ x = casadi__DMatrix__hasNZ (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__hasNonStructuralZeros" c_casadi__DMatrix__hasNonStructuralZeros + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__hasNonStructuralZeros + :: DMatrix -> IO Bool +casadi__DMatrix__hasNonStructuralZeros x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__hasNonStructuralZeros errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_hasNonStructuralZeros :: DMatrixClass a => a -> IO Bool +dmatrix_hasNonStructuralZeros x = casadi__DMatrix__hasNonStructuralZeros (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__inf__0" c_casadi__DMatrix__inf__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__inf__0 + :: (Int, Int) -> IO DMatrix +casadi__DMatrix__inf__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__inf__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_inf__0 :: (Int, Int) -> IO DMatrix +dmatrix_inf__0 = casadi__DMatrix__inf__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__inf__1" c_casadi__DMatrix__inf__1 + :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') +casadi__DMatrix__inf__1 + :: IO DMatrix +casadi__DMatrix__inf__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__inf__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_inf__1 :: IO DMatrix +dmatrix_inf__1 = casadi__DMatrix__inf__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__inf__2" c_casadi__DMatrix__inf__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__inf__2 + :: Int -> IO DMatrix +casadi__DMatrix__inf__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__inf__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_inf__2 :: Int -> IO DMatrix +dmatrix_inf__2 = casadi__DMatrix__inf__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__inf__3" c_casadi__DMatrix__inf__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__inf__3 + :: Int -> Int -> IO DMatrix +casadi__DMatrix__inf__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__inf__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_inf__3 :: Int -> Int -> IO DMatrix +dmatrix_inf__3 = casadi__DMatrix__inf__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__inf__4" c_casadi__DMatrix__inf__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi__DMatrix__inf__4 + :: Sparsity -> IO DMatrix +casadi__DMatrix__inf__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__inf__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_inf__4 :: Sparsity -> IO DMatrix +dmatrix_inf__4 = casadi__DMatrix__inf__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isCommutative" c_casadi__DMatrix__isCommutative + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isCommutative + :: DMatrix -> IO Bool +casadi__DMatrix__isCommutative x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isCommutative errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isCommutative :: DMatrixClass a => a -> IO Bool +dmatrix_isCommutative x = casadi__DMatrix__isCommutative (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isConstant" c_casadi__DMatrix__isConstant + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isConstant + :: DMatrix -> IO Bool +casadi__DMatrix__isConstant x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isConstant errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isConstant :: DMatrixClass a => a -> IO Bool +dmatrix_isConstant x = casadi__DMatrix__isConstant (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isIdentity" c_casadi__DMatrix__isIdentity + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isIdentity + :: DMatrix -> IO Bool +casadi__DMatrix__isIdentity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isIdentity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isIdentity :: DMatrixClass a => a -> IO Bool +dmatrix_isIdentity x = casadi__DMatrix__isIdentity (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isInteger" c_casadi__DMatrix__isInteger + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isInteger + :: DMatrix -> IO Bool +casadi__DMatrix__isInteger x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isInteger errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isInteger :: DMatrixClass a => a -> IO Bool +dmatrix_isInteger x = casadi__DMatrix__isInteger (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isLeaf" c_casadi__DMatrix__isLeaf + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isLeaf + :: DMatrix -> IO Bool +casadi__DMatrix__isLeaf x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isLeaf errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isLeaf :: DMatrixClass a => a -> IO Bool +dmatrix_isLeaf x = casadi__DMatrix__isLeaf (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isMinusOne" c_casadi__DMatrix__isMinusOne + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isMinusOne + :: DMatrix -> IO Bool +casadi__DMatrix__isMinusOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isMinusOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isMinusOne :: DMatrixClass a => a -> IO Bool +dmatrix_isMinusOne x = casadi__DMatrix__isMinusOne (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isOne" c_casadi__DMatrix__isOne + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isOne + :: DMatrix -> IO Bool +casadi__DMatrix__isOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isOne :: DMatrixClass a => a -> IO Bool +dmatrix_isOne x = casadi__DMatrix__isOne (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isRegular" c_casadi__DMatrix__isRegular + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isRegular + :: DMatrix -> IO Bool +casadi__DMatrix__isRegular x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isRegular errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isRegular :: DMatrixClass a => a -> IO Bool +dmatrix_isRegular x = casadi__DMatrix__isRegular (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isSlice__0" c_casadi__DMatrix__isSlice__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isSlice__0 + :: DMatrix -> IO Bool +casadi__DMatrix__isSlice__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isSlice__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isSlice__0 :: DMatrixClass a => a -> IO Bool +dmatrix_isSlice__0 x = casadi__DMatrix__isSlice__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isSlice__1" c_casadi__DMatrix__isSlice__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt +casadi__DMatrix__isSlice__1 + :: DMatrix -> Bool -> IO Bool +casadi__DMatrix__isSlice__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isSlice__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isSlice__1 :: DMatrixClass a => a -> Bool -> IO Bool +dmatrix_isSlice__1 x = casadi__DMatrix__isSlice__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isSmooth" c_casadi__DMatrix__isSmooth + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isSmooth + :: DMatrix -> IO Bool +casadi__DMatrix__isSmooth x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isSmooth errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isSmooth :: DMatrixClass a => a -> IO Bool +dmatrix_isSmooth x = casadi__DMatrix__isSmooth (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isSymbolic" c_casadi__DMatrix__isSymbolic + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isSymbolic + :: DMatrix -> IO Bool +casadi__DMatrix__isSymbolic x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isSymbolic errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isSymbolic :: DMatrixClass a => a -> IO Bool +dmatrix_isSymbolic x = casadi__DMatrix__isSymbolic (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isValidInput" c_casadi__DMatrix__isValidInput + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isValidInput + :: DMatrix -> IO Bool +casadi__DMatrix__isValidInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isValidInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isValidInput :: DMatrixClass a => a -> IO Bool +dmatrix_isValidInput x = casadi__DMatrix__isValidInput (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isZero" c_casadi__DMatrix__isZero + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isZero + :: DMatrix -> IO Bool +casadi__DMatrix__isZero x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isZero errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isZero :: DMatrixClass a => a -> IO Bool +dmatrix_isZero x = casadi__DMatrix__isZero (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__iscolumn" c_casadi__DMatrix__iscolumn + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__iscolumn + :: DMatrix -> IO Bool +casadi__DMatrix__iscolumn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__iscolumn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_iscolumn :: DMatrixClass a => a -> IO Bool +dmatrix_iscolumn x = casadi__DMatrix__iscolumn (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isdense" c_casadi__DMatrix__isdense + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isdense + :: DMatrix -> IO Bool +casadi__DMatrix__isdense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isdense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isdense :: DMatrixClass a => a -> IO Bool +dmatrix_isdense x = casadi__DMatrix__isdense (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isempty__0" c_casadi__DMatrix__isempty__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isempty__0 + :: DMatrix -> IO Bool +casadi__DMatrix__isempty__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isempty__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isempty__0 :: DMatrixClass a => a -> IO Bool +dmatrix_isempty__0 x = casadi__DMatrix__isempty__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isempty__1" c_casadi__DMatrix__isempty__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt +casadi__DMatrix__isempty__1 + :: DMatrix -> Bool -> IO Bool +casadi__DMatrix__isempty__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isempty__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isempty__1 :: DMatrixClass a => a -> Bool -> IO Bool +dmatrix_isempty__1 x = casadi__DMatrix__isempty__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isrow" c_casadi__DMatrix__isrow + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isrow + :: DMatrix -> IO Bool +casadi__DMatrix__isrow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isrow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isrow :: DMatrixClass a => a -> IO Bool +dmatrix_isrow x = casadi__DMatrix__isrow (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isscalar__0" c_casadi__DMatrix__isscalar__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isscalar__0 + :: DMatrix -> IO Bool +casadi__DMatrix__isscalar__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isscalar__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isscalar__0 :: DMatrixClass a => a -> IO Bool +dmatrix_isscalar__0 x = casadi__DMatrix__isscalar__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isscalar__1" c_casadi__DMatrix__isscalar__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt +casadi__DMatrix__isscalar__1 + :: DMatrix -> Bool -> IO Bool +casadi__DMatrix__isscalar__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isscalar__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isscalar__1 :: DMatrixClass a => a -> Bool -> IO Bool +dmatrix_isscalar__1 x = casadi__DMatrix__isscalar__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__issquare" c_casadi__DMatrix__issquare + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__issquare + :: DMatrix -> IO Bool +casadi__DMatrix__issquare x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__issquare errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_issquare :: DMatrixClass a => a -> IO Bool +dmatrix_issquare x = casadi__DMatrix__issquare (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__istril" c_casadi__DMatrix__istril + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__istril + :: DMatrix -> IO Bool +casadi__DMatrix__istril x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__istril errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_istril :: DMatrixClass a => a -> IO Bool +dmatrix_istril x = casadi__DMatrix__istril (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__istriu" c_casadi__DMatrix__istriu + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__istriu + :: DMatrix -> IO Bool +casadi__DMatrix__istriu x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__istriu errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_istriu :: DMatrixClass a => a -> IO Bool +dmatrix_istriu x = casadi__DMatrix__istriu (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__isvector" c_casadi__DMatrix__isvector + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__isvector + :: DMatrix -> IO Bool +casadi__DMatrix__isvector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__isvector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_isvector :: DMatrixClass a => a -> IO Bool +dmatrix_isvector x = casadi__DMatrix__isvector (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__makeSparse__0" c_casadi__DMatrix__makeSparse__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__makeSparse__0 + :: DMatrix -> IO () +casadi__DMatrix__makeSparse__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__makeSparse__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_makeSparse__0 :: DMatrixClass a => a -> IO () +dmatrix_makeSparse__0 x = casadi__DMatrix__makeSparse__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__makeSparse__1" c_casadi__DMatrix__makeSparse__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () +casadi__DMatrix__makeSparse__1 + :: DMatrix -> Double -> IO () +casadi__DMatrix__makeSparse__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__makeSparse__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_makeSparse__1 :: DMatrixClass a => a -> Double -> IO () +dmatrix_makeSparse__1 x = casadi__DMatrix__makeSparse__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__matrix_matrix" c_casadi__DMatrix__matrix_matrix + :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__matrix_matrix + :: Int -> DMatrix -> DMatrix -> IO DMatrix +casadi__DMatrix__matrix_matrix x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__matrix_matrix errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_matrix_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix +dmatrix_matrix_matrix = casadi__DMatrix__matrix_matrix + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__matrix_scalar" c_casadi__DMatrix__matrix_scalar + :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__matrix_scalar + :: Int -> DMatrix -> DMatrix -> IO DMatrix +casadi__DMatrix__matrix_scalar x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__matrix_scalar errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_matrix_scalar :: Int -> DMatrix -> DMatrix -> IO DMatrix +dmatrix_matrix_scalar = casadi__DMatrix__matrix_scalar + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nan__0" c_casadi__DMatrix__nan__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__nan__0 + :: (Int, Int) -> IO DMatrix +casadi__DMatrix__nan__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nan__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nan__0 :: (Int, Int) -> IO DMatrix +dmatrix_nan__0 = casadi__DMatrix__nan__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nan__1" c_casadi__DMatrix__nan__1 + :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') +casadi__DMatrix__nan__1 + :: IO DMatrix +casadi__DMatrix__nan__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nan__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nan__1 :: IO DMatrix +dmatrix_nan__1 = casadi__DMatrix__nan__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nan__2" c_casadi__DMatrix__nan__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__nan__2 + :: Int -> IO DMatrix +casadi__DMatrix__nan__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nan__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nan__2 :: Int -> IO DMatrix +dmatrix_nan__2 = casadi__DMatrix__nan__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nan__3" c_casadi__DMatrix__nan__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__nan__3 + :: Int -> Int -> IO DMatrix +casadi__DMatrix__nan__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nan__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nan__3 :: Int -> Int -> IO DMatrix +dmatrix_nan__3 = casadi__DMatrix__nan__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nan__4" c_casadi__DMatrix__nan__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi__DMatrix__nan__4 + :: Sparsity -> IO DMatrix +casadi__DMatrix__nan__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nan__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nan__4 :: Sparsity -> IO DMatrix +dmatrix_nan__4 = casadi__DMatrix__nan__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nnz" c_casadi__DMatrix__nnz + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__nnz + :: DMatrix -> IO Int +casadi__DMatrix__nnz x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nnz errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nnz :: DMatrixClass a => a -> IO Int +dmatrix_nnz x = casadi__DMatrix__nnz (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nonzeros" c_casadi__DMatrix__nonzeros + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CDouble)) +casadi__DMatrix__nonzeros + :: DMatrix -> IO (Vector Double) +casadi__DMatrix__nonzeros x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nonzeros errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nonzeros :: DMatrixClass a => a -> IO (Vector Double) +dmatrix_nonzeros x = casadi__DMatrix__nonzeros (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__nonzeros_int" c_casadi__DMatrix__nonzeros_int + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec CInt)) +casadi__DMatrix__nonzeros_int + :: DMatrix -> IO (Vector Int) +casadi__DMatrix__nonzeros_int x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__nonzeros_int errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_nonzeros_int :: DMatrixClass a => a -> IO (Vector Int) +dmatrix_nonzeros_int x = casadi__DMatrix__nonzeros_int (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__numel__0" c_casadi__DMatrix__numel__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt +casadi__DMatrix__numel__0 + :: DMatrix -> Int -> IO Int +casadi__DMatrix__numel__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__numel__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_numel__0 :: DMatrixClass a => a -> Int -> IO Int +dmatrix_numel__0 x = casadi__DMatrix__numel__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__numel__1" c_casadi__DMatrix__numel__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__numel__1 + :: DMatrix -> IO Int +casadi__DMatrix__numel__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__numel__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_numel__1 :: DMatrixClass a => a -> IO Int +dmatrix_numel__1 x = casadi__DMatrix__numel__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__ones__0" c_casadi__DMatrix__ones__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__ones__0 + :: (Int, Int) -> IO DMatrix +casadi__DMatrix__ones__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__ones__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_ones__0 :: (Int, Int) -> IO DMatrix +dmatrix_ones__0 = casadi__DMatrix__ones__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__ones__1" c_casadi__DMatrix__ones__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi__DMatrix__ones__1 + :: Sparsity -> IO DMatrix +casadi__DMatrix__ones__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__ones__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_ones__1 :: Sparsity -> IO DMatrix +dmatrix_ones__1 = casadi__DMatrix__ones__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__ones__2" c_casadi__DMatrix__ones__2 + :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') +casadi__DMatrix__ones__2 + :: IO DMatrix +casadi__DMatrix__ones__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__ones__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_ones__2 :: IO DMatrix +dmatrix_ones__2 = casadi__DMatrix__ones__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__ones__3" c_casadi__DMatrix__ones__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__ones__3 + :: Int -> IO DMatrix +casadi__DMatrix__ones__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__ones__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_ones__3 :: Int -> IO DMatrix +dmatrix_ones__3 = casadi__DMatrix__ones__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__ones__4" c_casadi__DMatrix__ones__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__ones__4 + :: Int -> Int -> IO DMatrix +casadi__DMatrix__ones__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__ones__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_ones__4 :: Int -> Int -> IO DMatrix +dmatrix_ones__4 = casadi__DMatrix__ones__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__operator_plus" c_casadi__DMatrix__operator_plus + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__operator_plus + :: DMatrix -> IO DMatrix +casadi__DMatrix__operator_plus x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__operator_plus errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_operator_plus :: DMatrixClass a => a -> IO DMatrix +dmatrix_operator_plus x = casadi__DMatrix__operator_plus (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__operator_minus" c_casadi__DMatrix__operator_minus + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__operator_minus + :: DMatrix -> IO DMatrix +casadi__DMatrix__operator_minus x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__operator_minus errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_operator_minus :: DMatrixClass a => a -> IO DMatrix +dmatrix_operator_minus x = casadi__DMatrix__operator_minus (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__printDense" c_casadi__DMatrix__printDense + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__printDense + :: DMatrix -> IO () +casadi__DMatrix__printDense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__printDense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_printDense :: DMatrixClass a => a -> IO () +dmatrix_printDense x = casadi__DMatrix__printDense (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__printScalar" c_casadi__DMatrix__printScalar + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__printScalar + :: DMatrix -> IO () +casadi__DMatrix__printScalar x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__printScalar errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_printScalar :: DMatrixClass a => a -> IO () +dmatrix_printScalar x = casadi__DMatrix__printScalar (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__printSparse" c_casadi__DMatrix__printSparse + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__printSparse + :: DMatrix -> IO () +casadi__DMatrix__printSparse x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__printSparse errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_printSparse :: DMatrixClass a => a -> IO () +dmatrix_printSparse x = casadi__DMatrix__printSparse (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__printSplit" c_casadi__DMatrix__printSplit + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO () +casadi__DMatrix__printSplit + :: DMatrix -> Vector String -> Vector String -> IO () +casadi__DMatrix__printSplit x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__printSplit errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_printSplit :: DMatrixClass a => a -> Vector String -> Vector String -> IO () +dmatrix_printSplit x = casadi__DMatrix__printSplit (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__printVector" c_casadi__DMatrix__printVector + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__printVector + :: DMatrix -> IO () +casadi__DMatrix__printVector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__printVector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_printVector :: DMatrixClass a => a -> IO () +dmatrix_printVector x = casadi__DMatrix__printVector (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__printme" c_casadi__DMatrix__printme + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__printme + :: DMatrix -> DMatrix -> IO DMatrix +casadi__DMatrix__printme x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__printme errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_printme :: DMatrixClass a => a -> DMatrix -> IO DMatrix +dmatrix_printme x = casadi__DMatrix__printme (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__remove" c_casadi__DMatrix__remove + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__DMatrix__remove + :: DMatrix -> Vector Int -> Vector Int -> IO () +casadi__DMatrix__remove x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__remove errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_remove :: DMatrixClass a => a -> Vector Int -> Vector Int -> IO () +dmatrix_remove x = casadi__DMatrix__remove (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__reserve__0" c_casadi__DMatrix__reserve__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO () +casadi__DMatrix__reserve__0 + :: DMatrix -> Int -> Int -> IO () +casadi__DMatrix__reserve__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__reserve__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_reserve__0 :: DMatrixClass a => a -> Int -> Int -> IO () +dmatrix_reserve__0 x = casadi__DMatrix__reserve__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__reserve__1" c_casadi__DMatrix__reserve__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO () +casadi__DMatrix__reserve__1 + :: DMatrix -> Int -> IO () +casadi__DMatrix__reserve__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__reserve__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_reserve__1 :: DMatrixClass a => a -> Int -> IO () +dmatrix_reserve__1 x = casadi__DMatrix__reserve__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__resetInput" c_casadi__DMatrix__resetInput + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__resetInput + :: DMatrix -> IO () +casadi__DMatrix__resetInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__resetInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_resetInput :: DMatrixClass a => a -> IO () +dmatrix_resetInput x = casadi__DMatrix__resetInput (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__resize" c_casadi__DMatrix__resize + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO () +casadi__DMatrix__resize + :: DMatrix -> Int -> Int -> IO () +casadi__DMatrix__resize x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__resize errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_resize :: DMatrixClass a => a -> Int -> Int -> IO () +dmatrix_resize x = casadi__DMatrix__resize (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__row" c_casadi__DMatrix__row + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt +casadi__DMatrix__row + :: DMatrix -> Int -> IO Int +casadi__DMatrix__row x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__row errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_row :: DMatrixClass a => a -> Int -> IO Int +dmatrix_row x = casadi__DMatrix__row (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sanityCheck__0" c_casadi__DMatrix__sanityCheck__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__sanityCheck__0 + :: DMatrix -> IO () +casadi__DMatrix__sanityCheck__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sanityCheck__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sanityCheck__0 :: DMatrixClass a => a -> IO () +dmatrix_sanityCheck__0 x = casadi__DMatrix__sanityCheck__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sanityCheck__1" c_casadi__DMatrix__sanityCheck__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO () +casadi__DMatrix__sanityCheck__1 + :: DMatrix -> Bool -> IO () +casadi__DMatrix__sanityCheck__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sanityCheck__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sanityCheck__1 :: DMatrixClass a => a -> Bool -> IO () +dmatrix_sanityCheck__1 x = casadi__DMatrix__sanityCheck__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__scalar_matrix" c_casadi__DMatrix__scalar_matrix + :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__scalar_matrix + :: Int -> DMatrix -> DMatrix -> IO DMatrix +casadi__DMatrix__scalar_matrix x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__scalar_matrix errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_scalar_matrix :: Int -> DMatrix -> DMatrix -> IO DMatrix +dmatrix_scalar_matrix = casadi__DMatrix__scalar_matrix + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__0" c_casadi__DMatrix__set__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__DMatrix__set__0 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () +casadi__DMatrix__set__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IMatrix -> IO () +dmatrix_set__0 x = casadi__DMatrix__set__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__1" c_casadi__DMatrix__set__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__DMatrix__set__1 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> Slice -> IO () +casadi__DMatrix__set__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__1 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> Slice -> IO () +dmatrix_set__1 x = casadi__DMatrix__set__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__2" c_casadi__DMatrix__set__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__DMatrix__set__2 + :: DMatrix -> DMatrix -> Bool -> Slice -> IMatrix -> IO () +casadi__DMatrix__set__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__2 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IMatrix -> IO () +dmatrix_set__2 x = casadi__DMatrix__set__2 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__3" c_casadi__DMatrix__set__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__DMatrix__set__3 + :: DMatrix -> DMatrix -> Bool -> Slice -> Slice -> IO () +casadi__DMatrix__set__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__3 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> Slice -> IO () +dmatrix_set__3 x = casadi__DMatrix__set__3 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__4" c_casadi__DMatrix__set__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Sparsity' -> IO () +casadi__DMatrix__set__4 + :: DMatrix -> DMatrix -> Bool -> Sparsity -> IO () +casadi__DMatrix__set__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__4 :: DMatrixClass a => a -> DMatrix -> Bool -> Sparsity -> IO () +dmatrix_set__4 x = casadi__DMatrix__set__4 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__5" c_casadi__DMatrix__set__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__DMatrix__set__5 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () +casadi__DMatrix__set__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__5 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () +dmatrix_set__5 x = casadi__DMatrix__set__5 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__6" c_casadi__DMatrix__set__6 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__DMatrix__set__6 + :: DMatrix -> DMatrix -> Bool -> Slice -> IO () +casadi__DMatrix__set__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__6 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () +dmatrix_set__6 x = casadi__DMatrix__set__6 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__7" c_casadi__DMatrix__set__7 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__DMatrix__set__7 + :: DMatrix -> Vector Double -> IO () +casadi__DMatrix__set__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__7 :: DMatrixClass a => a -> Vector Double -> IO () +dmatrix_set__7 x = casadi__DMatrix__set__7 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__8" c_casadi__DMatrix__set__8 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__DMatrix__set__8 + :: DMatrix -> Vector Double -> Bool -> IO () +casadi__DMatrix__set__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__8 :: DMatrixClass a => a -> Vector Double -> Bool -> IO () +dmatrix_set__8 x = casadi__DMatrix__set__8 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__9" c_casadi__DMatrix__set__9 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () +casadi__DMatrix__set__9 + :: DMatrix -> Double -> IO () +casadi__DMatrix__set__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__9 :: DMatrixClass a => a -> Double -> IO () +dmatrix_set__9 x = casadi__DMatrix__set__9 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__set__10" c_casadi__DMatrix__set__10 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO () +casadi__DMatrix__set__10 + :: DMatrix -> DMatrix -> IO () +casadi__DMatrix__set__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__set__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_set__10 :: DMatrixClass a => a -> DMatrix -> IO () +dmatrix_set__10 x = casadi__DMatrix__set__10 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setEqualityCheckingDepth__0" c_casadi__DMatrix__setEqualityCheckingDepth__0 + :: Ptr (Ptr StdString) -> IO () +casadi__DMatrix__setEqualityCheckingDepth__0 + :: IO () +casadi__DMatrix__setEqualityCheckingDepth__0 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setEqualityCheckingDepth__0 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setEqualityCheckingDepth__0 :: IO () +dmatrix_setEqualityCheckingDepth__0 = casadi__DMatrix__setEqualityCheckingDepth__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setEqualityCheckingDepth__1" c_casadi__DMatrix__setEqualityCheckingDepth__1 + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__DMatrix__setEqualityCheckingDepth__1 + :: Int -> IO () +casadi__DMatrix__setEqualityCheckingDepth__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setEqualityCheckingDepth__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setEqualityCheckingDepth__1 :: Int -> IO () +dmatrix_setEqualityCheckingDepth__1 = casadi__DMatrix__setEqualityCheckingDepth__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setNZ__0" c_casadi__DMatrix__setNZ__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__DMatrix__setNZ__0 + :: DMatrix -> DMatrix -> Bool -> IMatrix -> IO () +casadi__DMatrix__setNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setNZ__0 :: DMatrixClass a => a -> DMatrix -> Bool -> IMatrix -> IO () +dmatrix_setNZ__0 x = casadi__DMatrix__setNZ__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setNZ__1" c_casadi__DMatrix__setNZ__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__DMatrix__setNZ__1 + :: DMatrix -> DMatrix -> Bool -> Slice -> IO () +casadi__DMatrix__setNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setNZ__1 :: DMatrixClass a => a -> DMatrix -> Bool -> Slice -> IO () +dmatrix_setNZ__1 x = casadi__DMatrix__setNZ__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setNZ__2" c_casadi__DMatrix__setNZ__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__DMatrix__setNZ__2 + :: DMatrix -> Vector Double -> IO () +casadi__DMatrix__setNZ__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setNZ__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setNZ__2 :: DMatrixClass a => a -> Vector Double -> IO () +dmatrix_setNZ__2 x = casadi__DMatrix__setNZ__2 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setNZ__3" c_casadi__DMatrix__setNZ__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () +casadi__DMatrix__setNZ__3 + :: DMatrix -> Double -> IO () +casadi__DMatrix__setNZ__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setNZ__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setNZ__3 :: DMatrixClass a => a -> Double -> IO () +dmatrix_setNZ__3 x = casadi__DMatrix__setNZ__3 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setPrecision" c_casadi__DMatrix__setPrecision + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__DMatrix__setPrecision + :: Int -> IO () +casadi__DMatrix__setPrecision x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setPrecision errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setPrecision :: Int -> IO () +dmatrix_setPrecision = casadi__DMatrix__setPrecision + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setScientific" c_casadi__DMatrix__setScientific + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__DMatrix__setScientific + :: Bool -> IO () +casadi__DMatrix__setScientific x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setScientific errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setScientific :: Bool -> IO () +dmatrix_setScientific = casadi__DMatrix__setScientific + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setSym" c_casadi__DMatrix__setSym + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__DMatrix__setSym + :: DMatrix -> Vector Double -> IO () +casadi__DMatrix__setSym x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setSym errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setSym :: DMatrixClass a => a -> Vector Double -> IO () +dmatrix_setSym x = casadi__DMatrix__setSym (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setValue__0" c_casadi__DMatrix__setValue__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> CInt -> IO () +casadi__DMatrix__setValue__0 + :: DMatrix -> Double -> Int -> IO () +casadi__DMatrix__setValue__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setValue__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setValue__0 :: DMatrixClass a => a -> Double -> Int -> IO () +dmatrix_setValue__0 x = casadi__DMatrix__setValue__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setValue__1" c_casadi__DMatrix__setValue__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO () +casadi__DMatrix__setValue__1 + :: DMatrix -> Double -> IO () +casadi__DMatrix__setValue__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setValue__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setValue__1 :: DMatrixClass a => a -> Double -> IO () +dmatrix_setValue__1 x = casadi__DMatrix__setValue__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setWidth" c_casadi__DMatrix__setWidth + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__DMatrix__setWidth + :: Int -> IO () +casadi__DMatrix__setWidth x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setWidth errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setWidth :: Int -> IO () +dmatrix_setWidth = casadi__DMatrix__setWidth + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__setZero" c_casadi__DMatrix__setZero + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO () +casadi__DMatrix__setZero + :: DMatrix -> IO () +casadi__DMatrix__setZero x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__setZero errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_setZero :: DMatrixClass a => a -> IO () +dmatrix_setZero x = casadi__DMatrix__setZero (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__shape__0" c_casadi__DMatrix__shape__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO CInt +casadi__DMatrix__shape__0 + :: DMatrix -> Int -> IO Int +casadi__DMatrix__shape__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__shape__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_shape__0 :: DMatrixClass a => a -> Int -> IO Int +dmatrix_shape__0 x = casadi__DMatrix__shape__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__shape__1" c_casadi__DMatrix__shape__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdPair CInt CInt)) +casadi__DMatrix__shape__1 + :: DMatrix -> IO (Int, Int) +casadi__DMatrix__shape__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__shape__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_shape__1 :: DMatrixClass a => a -> IO (Int, Int) +dmatrix_shape__1 x = casadi__DMatrix__shape__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__size" c_casadi__DMatrix__size + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__size + :: DMatrix -> IO Int +casadi__DMatrix__size x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__size errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_size :: DMatrixClass a => a -> IO Int +dmatrix_size x = casadi__DMatrix__size (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__size1" c_casadi__DMatrix__size1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__size1 + :: DMatrix -> IO Int +casadi__DMatrix__size1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__size1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_size1 :: DMatrixClass a => a -> IO Int +dmatrix_size1 x = casadi__DMatrix__size1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__size2" c_casadi__DMatrix__size2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__size2 + :: DMatrix -> IO Int +casadi__DMatrix__size2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__size2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_size2 :: DMatrixClass a => a -> IO Int +dmatrix_size2 x = casadi__DMatrix__size2 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sizeD" c_casadi__DMatrix__sizeD + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__sizeD + :: DMatrix -> IO Int +casadi__DMatrix__sizeD x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sizeD errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sizeD :: DMatrixClass a => a -> IO Int +dmatrix_sizeD x = casadi__DMatrix__sizeD (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sizeL" c_casadi__DMatrix__sizeL + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__sizeL + :: DMatrix -> IO Int +casadi__DMatrix__sizeL x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sizeL errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sizeL :: DMatrixClass a => a -> IO Int +dmatrix_sizeL x = casadi__DMatrix__sizeL (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sizeU" c_casadi__DMatrix__sizeU + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi__DMatrix__sizeU + :: DMatrix -> IO Int +casadi__DMatrix__sizeU x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sizeU errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sizeU :: DMatrixClass a => a -> IO Int +dmatrix_sizeU x = casadi__DMatrix__sizeU (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sparse__0" c_casadi__DMatrix__sparse__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__sparse__0 + :: Sparsity -> DMatrix -> IO DMatrix +casadi__DMatrix__sparse__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sparse__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sparse__0 :: Sparsity -> DMatrix -> IO DMatrix +dmatrix_sparse__0 = casadi__DMatrix__sparse__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sparse__1" c_casadi__DMatrix__sparse__1 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__sparse__1 + :: (Int, Int) -> IO DMatrix +casadi__DMatrix__sparse__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sparse__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sparse__1 :: (Int, Int) -> IO DMatrix +dmatrix_sparse__1 = casadi__DMatrix__sparse__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sparse__2" c_casadi__DMatrix__sparse__2 + :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') +casadi__DMatrix__sparse__2 + :: IO DMatrix +casadi__DMatrix__sparse__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sparse__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sparse__2 :: IO DMatrix +dmatrix_sparse__2 = casadi__DMatrix__sparse__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sparse__3" c_casadi__DMatrix__sparse__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__sparse__3 + :: Int -> IO DMatrix +casadi__DMatrix__sparse__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sparse__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sparse__3 :: Int -> IO DMatrix +dmatrix_sparse__3 = casadi__DMatrix__sparse__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sparse__4" c_casadi__DMatrix__sparse__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__sparse__4 + :: Int -> Int -> IO DMatrix +casadi__DMatrix__sparse__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sparse__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sparse__4 :: Int -> Int -> IO DMatrix +dmatrix_sparse__4 = casadi__DMatrix__sparse__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sparsity" c_casadi__DMatrix__sparsity + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Sparsity') +casadi__DMatrix__sparsity + :: DMatrix -> IO Sparsity +casadi__DMatrix__sparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sparsity :: DMatrixClass a => a -> IO Sparsity +dmatrix_sparsity x = casadi__DMatrix__sparsity (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__0" c_casadi__DMatrix__sym__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) +casadi__DMatrix__sym__0 + :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix)) +casadi__DMatrix__sym__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector DMatrix)) +dmatrix_sym__0 = casadi__DMatrix__sym__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__1" c_casadi__DMatrix__sym__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) +casadi__DMatrix__sym__1 + :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix)) +casadi__DMatrix__sym__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector DMatrix)) +dmatrix_sym__1 = casadi__DMatrix__sym__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__2" c_casadi__DMatrix__sym__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi__DMatrix__sym__2 + :: String -> Int -> Int -> Int -> IO (Vector DMatrix) +casadi__DMatrix__sym__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector DMatrix) +dmatrix_sym__2 = casadi__DMatrix__sym__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__3" c_casadi__DMatrix__sym__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi__DMatrix__sym__3 + :: String -> Sparsity -> Int -> IO (Vector DMatrix) +casadi__DMatrix__sym__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector DMatrix) +dmatrix_sym__3 = casadi__DMatrix__sym__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__4" c_casadi__DMatrix__sym__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi__DMatrix__sym__4 + :: String -> Sparsity -> IO DMatrix +casadi__DMatrix__sym__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__4 :: String -> Sparsity -> IO DMatrix +dmatrix_sym__4 = casadi__DMatrix__sym__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__5" c_casadi__DMatrix__sym__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__sym__5 + :: String -> (Int, Int) -> IO DMatrix +casadi__DMatrix__sym__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__5 :: String -> (Int, Int) -> IO DMatrix +dmatrix_sym__5 = casadi__DMatrix__sym__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__6" c_casadi__DMatrix__sym__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr DMatrix') +casadi__DMatrix__sym__6 + :: String -> IO DMatrix +casadi__DMatrix__sym__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__6 :: String -> IO DMatrix +dmatrix_sym__6 = casadi__DMatrix__sym__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__7" c_casadi__DMatrix__sym__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__sym__7 + :: String -> Int -> IO DMatrix +casadi__DMatrix__sym__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__7 :: String -> Int -> IO DMatrix +dmatrix_sym__7 = casadi__DMatrix__sym__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__sym__8" c_casadi__DMatrix__sym__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__sym__8 + :: String -> Int -> Int -> IO DMatrix +casadi__DMatrix__sym__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__sym__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_sym__8 :: String -> Int -> Int -> IO DMatrix +dmatrix_sym__8 = casadi__DMatrix__sym__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__toSlice__0" c_casadi__DMatrix__toSlice__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr Slice') +casadi__DMatrix__toSlice__0 + :: DMatrix -> IO Slice +casadi__DMatrix__toSlice__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__toSlice__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_toSlice__0 :: DMatrixClass a => a -> IO Slice +dmatrix_toSlice__0 x = casadi__DMatrix__toSlice__0 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__toSlice__1" c_casadi__DMatrix__toSlice__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr Slice') +casadi__DMatrix__toSlice__1 + :: DMatrix -> Bool -> IO Slice +casadi__DMatrix__toSlice__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__toSlice__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_toSlice__1 :: DMatrixClass a => a -> Bool -> IO Slice +dmatrix_toSlice__1 x = casadi__DMatrix__toSlice__1 (castDMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__triplet__0" c_casadi__DMatrix__triplet__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__triplet__0 + :: Vector Int -> Vector Int -> DMatrix -> (Int, Int) -> IO DMatrix +casadi__DMatrix__triplet__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__triplet__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_triplet__0 :: Vector Int -> Vector Int -> DMatrix -> (Int, Int) -> IO DMatrix +dmatrix_triplet__0 = casadi__DMatrix__triplet__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__triplet__1" c_casadi__DMatrix__triplet__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__triplet__1 + :: Vector Int -> Vector Int -> DMatrix -> Int -> Int -> IO DMatrix +casadi__DMatrix__triplet__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__triplet__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_triplet__1 :: Vector Int -> Vector Int -> DMatrix -> Int -> Int -> IO DMatrix +dmatrix_triplet__1 = casadi__DMatrix__triplet__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__triplet__2" c_casadi__DMatrix__triplet__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__triplet__2 + :: Vector Int -> Vector Int -> DMatrix -> IO DMatrix +casadi__DMatrix__triplet__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__triplet__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_triplet__2 :: Vector Int -> Vector Int -> DMatrix -> IO DMatrix +dmatrix_triplet__2 = casadi__DMatrix__triplet__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__unary" c_casadi__DMatrix__unary + :: Ptr (Ptr StdString) -> CInt -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi__DMatrix__unary + :: Int -> DMatrix -> IO DMatrix +casadi__DMatrix__unary x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__unary errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_unary :: Int -> DMatrix -> IO DMatrix +dmatrix_unary = casadi__DMatrix__unary + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__zeros__0" c_casadi__DMatrix__zeros__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi__DMatrix__zeros__0 + :: (Int, Int) -> IO DMatrix +casadi__DMatrix__zeros__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__zeros__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_zeros__0 :: (Int, Int) -> IO DMatrix +dmatrix_zeros__0 = casadi__DMatrix__zeros__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__zeros__1" c_casadi__DMatrix__zeros__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi__DMatrix__zeros__1 + :: Sparsity -> IO DMatrix +casadi__DMatrix__zeros__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__zeros__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_zeros__1 :: Sparsity -> IO DMatrix +dmatrix_zeros__1 = casadi__DMatrix__zeros__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__zeros__2" c_casadi__DMatrix__zeros__2 + :: Ptr (Ptr StdString) -> IO (Ptr DMatrix') +casadi__DMatrix__zeros__2 + :: IO DMatrix +casadi__DMatrix__zeros__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__zeros__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_zeros__2 :: IO DMatrix +dmatrix_zeros__2 = casadi__DMatrix__zeros__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__zeros__3" c_casadi__DMatrix__zeros__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__zeros__3 + :: Int -> IO DMatrix +casadi__DMatrix__zeros__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__zeros__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_zeros__3 :: Int -> IO DMatrix +dmatrix_zeros__3 = casadi__DMatrix__zeros__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DMatrix__zeros__4" c_casadi__DMatrix__zeros__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr DMatrix') +casadi__DMatrix__zeros__4 + :: Int -> Int -> IO DMatrix +casadi__DMatrix__zeros__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DMatrix__zeros__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dmatrix_zeros__4 :: Int -> Int -> IO DMatrix +dmatrix_zeros__4 = casadi__DMatrix__zeros__4 -- direct wrapper diff --git a/Casadi/Core/Classes/DaeBuilder.hs b/Casadi/Core/Classes/DaeBuilder.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/DaeBuilder.hs @@ -0,0 +1,2379 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.DaeBuilder + ( + DaeBuilder, + DaeBuilderClass(..), + daeBuilder, + daeBuilder_addLinearCombination, + daeBuilder_addVariable__0, + daeBuilder_addVariable__1, + daeBuilder_addVariable__2, + daeBuilder_addVariable__3, + daeBuilder_add_alg__0, + daeBuilder_add_alg__1, + daeBuilder_add_d__0, + daeBuilder_add_d__1, + daeBuilder_add_dae__0, + daeBuilder_add_dae__1, + daeBuilder_add_ode__0, + daeBuilder_add_ode__1, + daeBuilder_add_p__0, + daeBuilder_add_p__1, + daeBuilder_add_p__2, + daeBuilder_add_q__0, + daeBuilder_add_q__1, + daeBuilder_add_q__2, + daeBuilder_add_quad__0, + daeBuilder_add_quad__1, + daeBuilder_add_s__0, + daeBuilder_add_s__1, + daeBuilder_add_s__2, + daeBuilder_add_u__0, + daeBuilder_add_u__1, + daeBuilder_add_u__2, + daeBuilder_add_x__0, + daeBuilder_add_x__1, + daeBuilder_add_x__2, + daeBuilder_add_y__0, + daeBuilder_add_y__1, + daeBuilder_add_z__0, + daeBuilder_add_z__1, + daeBuilder_add_z__2, + daeBuilder_create, + daeBuilder_der__0, + daeBuilder_der__1, + daeBuilder_derivativeStart__0, + daeBuilder_derivativeStart__1, + daeBuilder_derivativeStart__2, + daeBuilder_derivativeStart__3, + daeBuilder_eliminate_alg, + daeBuilder_eliminate_d, + daeBuilder_eliminate_quad, + daeBuilder_getDescription, + daeBuilder_getRepresentation, + daeBuilder_initialGuess__0, + daeBuilder_initialGuess__1, + daeBuilder_initialGuess__2, + daeBuilder_initialGuess__3, + daeBuilder_makeExplicit, + daeBuilder_makeSemiExplicit, + daeBuilder_max__0, + daeBuilder_max__1, + daeBuilder_max__2, + daeBuilder_max__3, + daeBuilder_min__0, + daeBuilder_min__1, + daeBuilder_min__2, + daeBuilder_min__3, + daeBuilder_nominal__0, + daeBuilder_nominal__1, + daeBuilder_operator_call, + daeBuilder_parseFMI, + daeBuilder_sanityCheck, + daeBuilder_scaleEquations, + daeBuilder_scaleVariables, + daeBuilder_setDerivativeStart__0, + daeBuilder_setDerivativeStart__1, + daeBuilder_setDerivativeStart__2, + daeBuilder_setDerivativeStart__3, + daeBuilder_setInitialGuess__0, + daeBuilder_setInitialGuess__1, + daeBuilder_setInitialGuess__2, + daeBuilder_setInitialGuess__3, + daeBuilder_setMax__0, + daeBuilder_setMax__1, + daeBuilder_setMax__2, + daeBuilder_setMax__3, + daeBuilder_setMin__0, + daeBuilder_setMin__1, + daeBuilder_setMin__2, + daeBuilder_setMin__3, + daeBuilder_setNominal__0, + daeBuilder_setNominal__1, + daeBuilder_setStart__0, + daeBuilder_setStart__1, + daeBuilder_setStart__2, + daeBuilder_setStart__3, + daeBuilder_setUnit, + daeBuilder_sort_alg, + daeBuilder_sort_d, + daeBuilder_sort_dae, + daeBuilder_split_d, + daeBuilder_split_dae, + daeBuilder_start__0, + daeBuilder_start__1, + daeBuilder_start__2, + daeBuilder_start__3, + daeBuilder_unit__0, + daeBuilder_unit__1, + daeBuilder_variable__0, + daeBuilder_variable__1, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__CONSTRUCTOR" c_casadi__DaeBuilder__CONSTRUCTOR + :: Ptr (Ptr StdString) -> IO (Ptr DaeBuilder') +casadi__DaeBuilder__CONSTRUCTOR + :: IO DaeBuilder +casadi__DaeBuilder__CONSTRUCTOR = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__CONSTRUCTOR errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder :: IO DaeBuilder +daeBuilder = casadi__DaeBuilder__CONSTRUCTOR + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__addLinearCombination" c_casadi__DaeBuilder__addLinearCombination + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr MX') +casadi__DaeBuilder__addLinearCombination + :: DaeBuilder -> String -> Vector String -> IO MX +casadi__DaeBuilder__addLinearCombination x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__addLinearCombination errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_addLinearCombination :: DaeBuilderClass a => a -> String -> Vector String -> IO MX +daeBuilder_addLinearCombination x = casadi__DaeBuilder__addLinearCombination (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__addVariable__0" c_casadi__DaeBuilder__addVariable__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX') +casadi__DaeBuilder__addVariable__0 + :: DaeBuilder -> String -> Sparsity -> IO MX +casadi__DaeBuilder__addVariable__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__addVariable__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_addVariable__0 :: DaeBuilderClass a => a -> String -> Sparsity -> IO MX +daeBuilder_addVariable__0 x = casadi__DaeBuilder__addVariable__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__addVariable__1" c_casadi__DaeBuilder__addVariable__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__addVariable__1 + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__addVariable__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__addVariable__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_addVariable__1 :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_addVariable__1 x = casadi__DaeBuilder__addVariable__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__addVariable__2" c_casadi__DaeBuilder__addVariable__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX') +casadi__DaeBuilder__addVariable__2 + :: DaeBuilder -> String -> Int -> IO MX +casadi__DaeBuilder__addVariable__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__addVariable__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_addVariable__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX +daeBuilder_addVariable__2 x = casadi__DaeBuilder__addVariable__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__addVariable__3" c_casadi__DaeBuilder__addVariable__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr Variable' -> IO () +casadi__DaeBuilder__addVariable__3 + :: DaeBuilder -> String -> Variable -> IO () +casadi__DaeBuilder__addVariable__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__addVariable__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_addVariable__3 :: DaeBuilderClass a => a -> String -> Variable -> IO () +daeBuilder_addVariable__3 x = casadi__DaeBuilder__addVariable__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_alg__0" c_casadi__DaeBuilder__add_alg__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO () +casadi__DaeBuilder__add_alg__0 + :: DaeBuilder -> MX -> IO () +casadi__DaeBuilder__add_alg__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_alg__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_alg__0 :: DaeBuilderClass a => a -> MX -> IO () +daeBuilder_add_alg__0 x = casadi__DaeBuilder__add_alg__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_alg__1" c_casadi__DaeBuilder__add_alg__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO () +casadi__DaeBuilder__add_alg__1 + :: DaeBuilder -> MX -> String -> IO () +casadi__DaeBuilder__add_alg__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_alg__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_alg__1 :: DaeBuilderClass a => a -> MX -> String -> IO () +daeBuilder_add_alg__1 x = casadi__DaeBuilder__add_alg__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_d__0" c_casadi__DaeBuilder__add_d__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX') +casadi__DaeBuilder__add_d__0 + :: DaeBuilder -> MX -> IO MX +casadi__DaeBuilder__add_d__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_d__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_d__0 :: DaeBuilderClass a => a -> MX -> IO MX +daeBuilder_add_d__0 x = casadi__DaeBuilder__add_d__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_d__1" c_casadi__DaeBuilder__add_d__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__add_d__1 + :: DaeBuilder -> MX -> String -> IO MX +casadi__DaeBuilder__add_d__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_d__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_d__1 :: DaeBuilderClass a => a -> MX -> String -> IO MX +daeBuilder_add_d__1 x = casadi__DaeBuilder__add_d__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_dae__0" c_casadi__DaeBuilder__add_dae__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO () +casadi__DaeBuilder__add_dae__0 + :: DaeBuilder -> MX -> IO () +casadi__DaeBuilder__add_dae__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_dae__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_dae__0 :: DaeBuilderClass a => a -> MX -> IO () +daeBuilder_add_dae__0 x = casadi__DaeBuilder__add_dae__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_dae__1" c_casadi__DaeBuilder__add_dae__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO () +casadi__DaeBuilder__add_dae__1 + :: DaeBuilder -> MX -> String -> IO () +casadi__DaeBuilder__add_dae__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_dae__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_dae__1 :: DaeBuilderClass a => a -> MX -> String -> IO () +daeBuilder_add_dae__1 x = casadi__DaeBuilder__add_dae__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_ode__0" c_casadi__DaeBuilder__add_ode__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO () +casadi__DaeBuilder__add_ode__0 + :: DaeBuilder -> MX -> IO () +casadi__DaeBuilder__add_ode__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_ode__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_ode__0 :: DaeBuilderClass a => a -> MX -> IO () +daeBuilder_add_ode__0 x = casadi__DaeBuilder__add_ode__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_ode__1" c_casadi__DaeBuilder__add_ode__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO () +casadi__DaeBuilder__add_ode__1 + :: DaeBuilder -> MX -> String -> IO () +casadi__DaeBuilder__add_ode__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_ode__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_ode__1 :: DaeBuilderClass a => a -> MX -> String -> IO () +daeBuilder_add_ode__1 x = casadi__DaeBuilder__add_ode__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_p__0" c_casadi__DaeBuilder__add_p__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX') +casadi__DaeBuilder__add_p__0 + :: DaeBuilder -> IO MX +casadi__DaeBuilder__add_p__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_p__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_p__0 :: DaeBuilderClass a => a -> IO MX +daeBuilder_add_p__0 x = casadi__DaeBuilder__add_p__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_p__1" c_casadi__DaeBuilder__add_p__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__add_p__1 + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__add_p__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_p__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_p__1 :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_add_p__1 x = casadi__DaeBuilder__add_p__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_p__2" c_casadi__DaeBuilder__add_p__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX') +casadi__DaeBuilder__add_p__2 + :: DaeBuilder -> String -> Int -> IO MX +casadi__DaeBuilder__add_p__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_p__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_p__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX +daeBuilder_add_p__2 x = casadi__DaeBuilder__add_p__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_q__0" c_casadi__DaeBuilder__add_q__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX') +casadi__DaeBuilder__add_q__0 + :: DaeBuilder -> IO MX +casadi__DaeBuilder__add_q__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_q__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_q__0 :: DaeBuilderClass a => a -> IO MX +daeBuilder_add_q__0 x = casadi__DaeBuilder__add_q__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_q__1" c_casadi__DaeBuilder__add_q__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__add_q__1 + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__add_q__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_q__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_q__1 :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_add_q__1 x = casadi__DaeBuilder__add_q__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_q__2" c_casadi__DaeBuilder__add_q__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX') +casadi__DaeBuilder__add_q__2 + :: DaeBuilder -> String -> Int -> IO MX +casadi__DaeBuilder__add_q__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_q__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_q__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX +daeBuilder_add_q__2 x = casadi__DaeBuilder__add_q__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_quad__0" c_casadi__DaeBuilder__add_quad__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO () +casadi__DaeBuilder__add_quad__0 + :: DaeBuilder -> MX -> IO () +casadi__DaeBuilder__add_quad__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_quad__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_quad__0 :: DaeBuilderClass a => a -> MX -> IO () +daeBuilder_add_quad__0 x = casadi__DaeBuilder__add_quad__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_quad__1" c_casadi__DaeBuilder__add_quad__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO () +casadi__DaeBuilder__add_quad__1 + :: DaeBuilder -> MX -> String -> IO () +casadi__DaeBuilder__add_quad__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_quad__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_quad__1 :: DaeBuilderClass a => a -> MX -> String -> IO () +daeBuilder_add_quad__1 x = casadi__DaeBuilder__add_quad__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_s__0" c_casadi__DaeBuilder__add_s__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr (StdPair (Ptr MX') (Ptr MX'))) +casadi__DaeBuilder__add_s__0 + :: DaeBuilder -> IO (MX, MX) +casadi__DaeBuilder__add_s__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_s__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_s__0 :: DaeBuilderClass a => a -> IO (MX, MX) +daeBuilder_add_s__0 x = casadi__DaeBuilder__add_s__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_s__1" c_casadi__DaeBuilder__add_s__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr (StdPair (Ptr MX') (Ptr MX'))) +casadi__DaeBuilder__add_s__1 + :: DaeBuilder -> String -> IO (MX, MX) +casadi__DaeBuilder__add_s__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_s__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_s__1 :: DaeBuilderClass a => a -> String -> IO (MX, MX) +daeBuilder_add_s__1 x = casadi__DaeBuilder__add_s__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_s__2" c_casadi__DaeBuilder__add_s__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr (StdPair (Ptr MX') (Ptr MX'))) +casadi__DaeBuilder__add_s__2 + :: DaeBuilder -> String -> Int -> IO (MX, MX) +casadi__DaeBuilder__add_s__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_s__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_s__2 :: DaeBuilderClass a => a -> String -> Int -> IO (MX, MX) +daeBuilder_add_s__2 x = casadi__DaeBuilder__add_s__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_u__0" c_casadi__DaeBuilder__add_u__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX') +casadi__DaeBuilder__add_u__0 + :: DaeBuilder -> IO MX +casadi__DaeBuilder__add_u__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_u__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_u__0 :: DaeBuilderClass a => a -> IO MX +daeBuilder_add_u__0 x = casadi__DaeBuilder__add_u__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_u__1" c_casadi__DaeBuilder__add_u__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__add_u__1 + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__add_u__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_u__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_u__1 :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_add_u__1 x = casadi__DaeBuilder__add_u__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_u__2" c_casadi__DaeBuilder__add_u__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX') +casadi__DaeBuilder__add_u__2 + :: DaeBuilder -> String -> Int -> IO MX +casadi__DaeBuilder__add_u__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_u__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_u__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX +daeBuilder_add_u__2 x = casadi__DaeBuilder__add_u__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_x__0" c_casadi__DaeBuilder__add_x__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX') +casadi__DaeBuilder__add_x__0 + :: DaeBuilder -> IO MX +casadi__DaeBuilder__add_x__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_x__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_x__0 :: DaeBuilderClass a => a -> IO MX +daeBuilder_add_x__0 x = casadi__DaeBuilder__add_x__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_x__1" c_casadi__DaeBuilder__add_x__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__add_x__1 + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__add_x__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_x__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_x__1 :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_add_x__1 x = casadi__DaeBuilder__add_x__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_x__2" c_casadi__DaeBuilder__add_x__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX') +casadi__DaeBuilder__add_x__2 + :: DaeBuilder -> String -> Int -> IO MX +casadi__DaeBuilder__add_x__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_x__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_x__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX +daeBuilder_add_x__2 x = casadi__DaeBuilder__add_x__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_y__0" c_casadi__DaeBuilder__add_y__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX') +casadi__DaeBuilder__add_y__0 + :: DaeBuilder -> MX -> IO MX +casadi__DaeBuilder__add_y__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_y__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_y__0 :: DaeBuilderClass a => a -> MX -> IO MX +daeBuilder_add_y__0 x = casadi__DaeBuilder__add_y__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_y__1" c_casadi__DaeBuilder__add_y__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__add_y__1 + :: DaeBuilder -> MX -> String -> IO MX +casadi__DaeBuilder__add_y__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_y__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_y__1 :: DaeBuilderClass a => a -> MX -> String -> IO MX +daeBuilder_add_y__1 x = casadi__DaeBuilder__add_y__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_z__0" c_casadi__DaeBuilder__add_z__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr MX') +casadi__DaeBuilder__add_z__0 + :: DaeBuilder -> IO MX +casadi__DaeBuilder__add_z__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_z__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_z__0 :: DaeBuilderClass a => a -> IO MX +daeBuilder_add_z__0 x = casadi__DaeBuilder__add_z__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_z__1" c_casadi__DaeBuilder__add_z__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__add_z__1 + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__add_z__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_z__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_z__1 :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_add_z__1 x = casadi__DaeBuilder__add_z__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__add_z__2" c_casadi__DaeBuilder__add_z__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO (Ptr MX') +casadi__DaeBuilder__add_z__2 + :: DaeBuilder -> String -> Int -> IO MX +casadi__DaeBuilder__add_z__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__add_z__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_add_z__2 :: DaeBuilderClass a => a -> String -> Int -> IO MX +daeBuilder_add_z__2 x = casadi__DaeBuilder__add_z__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__create" c_casadi__DaeBuilder__create + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr MXFunction') +casadi__DaeBuilder__create + :: DaeBuilder -> String -> Vector String -> Vector String -> IO MXFunction +casadi__DaeBuilder__create x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__create errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_create :: DaeBuilderClass a => a -> String -> Vector String -> Vector String -> IO MXFunction +daeBuilder_create x = casadi__DaeBuilder__create (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__der__0" c_casadi__DaeBuilder__der__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr MX') +casadi__DaeBuilder__der__0 + :: DaeBuilder -> MX -> IO MX +casadi__DaeBuilder__der__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__der__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_der__0 :: DaeBuilderClass a => a -> MX -> IO MX +daeBuilder_der__0 x = casadi__DaeBuilder__der__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__der__1" c_casadi__DaeBuilder__der__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__der__1 + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__der__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__der__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_der__1 :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_der__1 x = casadi__DaeBuilder__der__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__0" c_casadi__DaeBuilder__derivativeStart__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__derivativeStart__0 + :: DaeBuilder -> MX -> IO (Vector Double) +casadi__DaeBuilder__derivativeStart__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__derivativeStart__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_derivativeStart__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double) +daeBuilder_derivativeStart__0 x = casadi__DaeBuilder__derivativeStart__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__1" c_casadi__DaeBuilder__derivativeStart__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__derivativeStart__1 + :: DaeBuilder -> MX -> Bool -> IO (Vector Double) +casadi__DaeBuilder__derivativeStart__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__derivativeStart__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_derivativeStart__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double) +daeBuilder_derivativeStart__1 x = casadi__DaeBuilder__derivativeStart__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__2" c_casadi__DaeBuilder__derivativeStart__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble +casadi__DaeBuilder__derivativeStart__2 + :: DaeBuilder -> String -> IO Double +casadi__DaeBuilder__derivativeStart__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__derivativeStart__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_derivativeStart__2 :: DaeBuilderClass a => a -> String -> IO Double +daeBuilder_derivativeStart__2 x = casadi__DaeBuilder__derivativeStart__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__derivativeStart__3" c_casadi__DaeBuilder__derivativeStart__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble +casadi__DaeBuilder__derivativeStart__3 + :: DaeBuilder -> String -> Bool -> IO Double +casadi__DaeBuilder__derivativeStart__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__derivativeStart__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_derivativeStart__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double +daeBuilder_derivativeStart__3 x = casadi__DaeBuilder__derivativeStart__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__eliminate_alg" c_casadi__DaeBuilder__eliminate_alg + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__eliminate_alg + :: DaeBuilder -> IO () +casadi__DaeBuilder__eliminate_alg x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__eliminate_alg errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_eliminate_alg :: DaeBuilderClass a => a -> IO () +daeBuilder_eliminate_alg x = casadi__DaeBuilder__eliminate_alg (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__eliminate_d" c_casadi__DaeBuilder__eliminate_d + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__eliminate_d + :: DaeBuilder -> IO () +casadi__DaeBuilder__eliminate_d x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__eliminate_d errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_eliminate_d :: DaeBuilderClass a => a -> IO () +daeBuilder_eliminate_d x = casadi__DaeBuilder__eliminate_d (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__eliminate_quad" c_casadi__DaeBuilder__eliminate_quad + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__eliminate_quad + :: DaeBuilder -> IO () +casadi__DaeBuilder__eliminate_quad x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__eliminate_quad errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_eliminate_quad :: DaeBuilderClass a => a -> IO () +daeBuilder_eliminate_quad x = casadi__DaeBuilder__eliminate_quad (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__0" c_casadi__DaeBuilder__initialGuess__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__initialGuess__0 + :: DaeBuilder -> MX -> IO (Vector Double) +casadi__DaeBuilder__initialGuess__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__initialGuess__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_initialGuess__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double) +daeBuilder_initialGuess__0 x = casadi__DaeBuilder__initialGuess__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__1" c_casadi__DaeBuilder__initialGuess__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__initialGuess__1 + :: DaeBuilder -> MX -> Bool -> IO (Vector Double) +casadi__DaeBuilder__initialGuess__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__initialGuess__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_initialGuess__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double) +daeBuilder_initialGuess__1 x = casadi__DaeBuilder__initialGuess__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__2" c_casadi__DaeBuilder__initialGuess__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble +casadi__DaeBuilder__initialGuess__2 + :: DaeBuilder -> String -> IO Double +casadi__DaeBuilder__initialGuess__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__initialGuess__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_initialGuess__2 :: DaeBuilderClass a => a -> String -> IO Double +daeBuilder_initialGuess__2 x = casadi__DaeBuilder__initialGuess__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__initialGuess__3" c_casadi__DaeBuilder__initialGuess__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble +casadi__DaeBuilder__initialGuess__3 + :: DaeBuilder -> String -> Bool -> IO Double +casadi__DaeBuilder__initialGuess__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__initialGuess__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_initialGuess__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double +daeBuilder_initialGuess__3 x = casadi__DaeBuilder__initialGuess__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__makeExplicit" c_casadi__DaeBuilder__makeExplicit + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__makeExplicit + :: DaeBuilder -> IO () +casadi__DaeBuilder__makeExplicit x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__makeExplicit errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_makeExplicit :: DaeBuilderClass a => a -> IO () +daeBuilder_makeExplicit x = casadi__DaeBuilder__makeExplicit (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__makeSemiExplicit" c_casadi__DaeBuilder__makeSemiExplicit + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__makeSemiExplicit + :: DaeBuilder -> IO () +casadi__DaeBuilder__makeSemiExplicit x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__makeSemiExplicit errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_makeSemiExplicit :: DaeBuilderClass a => a -> IO () +daeBuilder_makeSemiExplicit x = casadi__DaeBuilder__makeSemiExplicit (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__max__0" c_casadi__DaeBuilder__max__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__max__0 + :: DaeBuilder -> MX -> IO (Vector Double) +casadi__DaeBuilder__max__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__max__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_max__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double) +daeBuilder_max__0 x = casadi__DaeBuilder__max__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__max__1" c_casadi__DaeBuilder__max__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__max__1 + :: DaeBuilder -> MX -> Bool -> IO (Vector Double) +casadi__DaeBuilder__max__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__max__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_max__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double) +daeBuilder_max__1 x = casadi__DaeBuilder__max__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__max__2" c_casadi__DaeBuilder__max__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble +casadi__DaeBuilder__max__2 + :: DaeBuilder -> String -> IO Double +casadi__DaeBuilder__max__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__max__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_max__2 :: DaeBuilderClass a => a -> String -> IO Double +daeBuilder_max__2 x = casadi__DaeBuilder__max__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__max__3" c_casadi__DaeBuilder__max__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble +casadi__DaeBuilder__max__3 + :: DaeBuilder -> String -> Bool -> IO Double +casadi__DaeBuilder__max__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__max__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_max__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double +daeBuilder_max__3 x = casadi__DaeBuilder__max__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__min__0" c_casadi__DaeBuilder__min__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__min__0 + :: DaeBuilder -> MX -> IO (Vector Double) +casadi__DaeBuilder__min__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__min__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_min__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double) +daeBuilder_min__0 x = casadi__DaeBuilder__min__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__min__1" c_casadi__DaeBuilder__min__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__min__1 + :: DaeBuilder -> MX -> Bool -> IO (Vector Double) +casadi__DaeBuilder__min__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__min__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_min__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double) +daeBuilder_min__1 x = casadi__DaeBuilder__min__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__min__2" c_casadi__DaeBuilder__min__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble +casadi__DaeBuilder__min__2 + :: DaeBuilder -> String -> IO Double +casadi__DaeBuilder__min__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__min__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_min__2 :: DaeBuilderClass a => a -> String -> IO Double +daeBuilder_min__2 x = casadi__DaeBuilder__min__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__min__3" c_casadi__DaeBuilder__min__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble +casadi__DaeBuilder__min__3 + :: DaeBuilder -> String -> Bool -> IO Double +casadi__DaeBuilder__min__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__min__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_min__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double +daeBuilder_min__3 x = casadi__DaeBuilder__min__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__nominal__0" c_casadi__DaeBuilder__nominal__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__nominal__0 + :: DaeBuilder -> MX -> IO (Vector Double) +casadi__DaeBuilder__nominal__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__nominal__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_nominal__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double) +daeBuilder_nominal__0 x = casadi__DaeBuilder__nominal__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__nominal__1" c_casadi__DaeBuilder__nominal__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble +casadi__DaeBuilder__nominal__1 + :: DaeBuilder -> String -> IO Double +casadi__DaeBuilder__nominal__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__nominal__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_nominal__1 :: DaeBuilderClass a => a -> String -> IO Double +daeBuilder_nominal__1 x = casadi__DaeBuilder__nominal__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__operator_call" c_casadi__DaeBuilder__operator_call + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr MX') +casadi__DaeBuilder__operator_call + :: DaeBuilder -> String -> IO MX +casadi__DaeBuilder__operator_call x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__operator_call errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_operator_call :: DaeBuilderClass a => a -> String -> IO MX +daeBuilder_operator_call x = casadi__DaeBuilder__operator_call (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__parseFMI" c_casadi__DaeBuilder__parseFMI + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO () +casadi__DaeBuilder__parseFMI + :: DaeBuilder -> String -> IO () +casadi__DaeBuilder__parseFMI x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__parseFMI errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_parseFMI :: DaeBuilderClass a => a -> String -> IO () +daeBuilder_parseFMI x = casadi__DaeBuilder__parseFMI (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__sanityCheck" c_casadi__DaeBuilder__sanityCheck + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__sanityCheck + :: DaeBuilder -> IO () +casadi__DaeBuilder__sanityCheck x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__sanityCheck errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_sanityCheck :: DaeBuilderClass a => a -> IO () +daeBuilder_sanityCheck x = casadi__DaeBuilder__sanityCheck (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__scaleEquations" c_casadi__DaeBuilder__scaleEquations + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__scaleEquations + :: DaeBuilder -> IO () +casadi__DaeBuilder__scaleEquations x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__scaleEquations errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_scaleEquations :: DaeBuilderClass a => a -> IO () +daeBuilder_scaleEquations x = casadi__DaeBuilder__scaleEquations (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__scaleVariables" c_casadi__DaeBuilder__scaleVariables + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__scaleVariables + :: DaeBuilder -> IO () +casadi__DaeBuilder__scaleVariables x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__scaleVariables errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_scaleVariables :: DaeBuilderClass a => a -> IO () +daeBuilder_scaleVariables x = casadi__DaeBuilder__scaleVariables (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__0" c_casadi__DaeBuilder__setDerivativeStart__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO () +casadi__DaeBuilder__setDerivativeStart__0 + :: DaeBuilder -> MX -> Vector Double -> IO () +casadi__DaeBuilder__setDerivativeStart__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setDerivativeStart__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setDerivativeStart__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO () +daeBuilder_setDerivativeStart__0 x = casadi__DaeBuilder__setDerivativeStart__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__1" c_casadi__DaeBuilder__setDerivativeStart__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__DaeBuilder__setDerivativeStart__1 + :: DaeBuilder -> MX -> Vector Double -> Bool -> IO () +casadi__DaeBuilder__setDerivativeStart__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setDerivativeStart__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setDerivativeStart__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO () +daeBuilder_setDerivativeStart__1 x = casadi__DaeBuilder__setDerivativeStart__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__2" c_casadi__DaeBuilder__setDerivativeStart__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO () +casadi__DaeBuilder__setDerivativeStart__2 + :: DaeBuilder -> String -> Double -> IO () +casadi__DaeBuilder__setDerivativeStart__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setDerivativeStart__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setDerivativeStart__2 :: DaeBuilderClass a => a -> String -> Double -> IO () +daeBuilder_setDerivativeStart__2 x = casadi__DaeBuilder__setDerivativeStart__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setDerivativeStart__3" c_casadi__DaeBuilder__setDerivativeStart__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO () +casadi__DaeBuilder__setDerivativeStart__3 + :: DaeBuilder -> String -> Double -> Bool -> IO () +casadi__DaeBuilder__setDerivativeStart__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setDerivativeStart__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setDerivativeStart__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO () +daeBuilder_setDerivativeStart__3 x = casadi__DaeBuilder__setDerivativeStart__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__0" c_casadi__DaeBuilder__setInitialGuess__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO () +casadi__DaeBuilder__setInitialGuess__0 + :: DaeBuilder -> MX -> Vector Double -> IO () +casadi__DaeBuilder__setInitialGuess__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setInitialGuess__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setInitialGuess__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO () +daeBuilder_setInitialGuess__0 x = casadi__DaeBuilder__setInitialGuess__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__1" c_casadi__DaeBuilder__setInitialGuess__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__DaeBuilder__setInitialGuess__1 + :: DaeBuilder -> MX -> Vector Double -> Bool -> IO () +casadi__DaeBuilder__setInitialGuess__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setInitialGuess__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setInitialGuess__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO () +daeBuilder_setInitialGuess__1 x = casadi__DaeBuilder__setInitialGuess__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__2" c_casadi__DaeBuilder__setInitialGuess__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO () +casadi__DaeBuilder__setInitialGuess__2 + :: DaeBuilder -> String -> Double -> IO () +casadi__DaeBuilder__setInitialGuess__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setInitialGuess__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setInitialGuess__2 :: DaeBuilderClass a => a -> String -> Double -> IO () +daeBuilder_setInitialGuess__2 x = casadi__DaeBuilder__setInitialGuess__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setInitialGuess__3" c_casadi__DaeBuilder__setInitialGuess__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO () +casadi__DaeBuilder__setInitialGuess__3 + :: DaeBuilder -> String -> Double -> Bool -> IO () +casadi__DaeBuilder__setInitialGuess__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setInitialGuess__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setInitialGuess__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO () +daeBuilder_setInitialGuess__3 x = casadi__DaeBuilder__setInitialGuess__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMax__0" c_casadi__DaeBuilder__setMax__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO () +casadi__DaeBuilder__setMax__0 + :: DaeBuilder -> MX -> Vector Double -> IO () +casadi__DaeBuilder__setMax__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMax__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMax__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO () +daeBuilder_setMax__0 x = casadi__DaeBuilder__setMax__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMax__1" c_casadi__DaeBuilder__setMax__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__DaeBuilder__setMax__1 + :: DaeBuilder -> MX -> Vector Double -> Bool -> IO () +casadi__DaeBuilder__setMax__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMax__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMax__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO () +daeBuilder_setMax__1 x = casadi__DaeBuilder__setMax__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMax__2" c_casadi__DaeBuilder__setMax__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO () +casadi__DaeBuilder__setMax__2 + :: DaeBuilder -> String -> Double -> IO () +casadi__DaeBuilder__setMax__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMax__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMax__2 :: DaeBuilderClass a => a -> String -> Double -> IO () +daeBuilder_setMax__2 x = casadi__DaeBuilder__setMax__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMax__3" c_casadi__DaeBuilder__setMax__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO () +casadi__DaeBuilder__setMax__3 + :: DaeBuilder -> String -> Double -> Bool -> IO () +casadi__DaeBuilder__setMax__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMax__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMax__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO () +daeBuilder_setMax__3 x = casadi__DaeBuilder__setMax__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMin__0" c_casadi__DaeBuilder__setMin__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO () +casadi__DaeBuilder__setMin__0 + :: DaeBuilder -> MX -> Vector Double -> IO () +casadi__DaeBuilder__setMin__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMin__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMin__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO () +daeBuilder_setMin__0 x = casadi__DaeBuilder__setMin__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMin__1" c_casadi__DaeBuilder__setMin__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__DaeBuilder__setMin__1 + :: DaeBuilder -> MX -> Vector Double -> Bool -> IO () +casadi__DaeBuilder__setMin__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMin__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMin__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO () +daeBuilder_setMin__1 x = casadi__DaeBuilder__setMin__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMin__2" c_casadi__DaeBuilder__setMin__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO () +casadi__DaeBuilder__setMin__2 + :: DaeBuilder -> String -> Double -> IO () +casadi__DaeBuilder__setMin__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMin__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMin__2 :: DaeBuilderClass a => a -> String -> Double -> IO () +daeBuilder_setMin__2 x = casadi__DaeBuilder__setMin__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setMin__3" c_casadi__DaeBuilder__setMin__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO () +casadi__DaeBuilder__setMin__3 + :: DaeBuilder -> String -> Double -> Bool -> IO () +casadi__DaeBuilder__setMin__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setMin__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setMin__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO () +daeBuilder_setMin__3 x = casadi__DaeBuilder__setMin__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setNominal__0" c_casadi__DaeBuilder__setNominal__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO () +casadi__DaeBuilder__setNominal__0 + :: DaeBuilder -> MX -> Vector Double -> IO () +casadi__DaeBuilder__setNominal__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setNominal__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setNominal__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO () +daeBuilder_setNominal__0 x = casadi__DaeBuilder__setNominal__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setNominal__1" c_casadi__DaeBuilder__setNominal__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO () +casadi__DaeBuilder__setNominal__1 + :: DaeBuilder -> String -> Double -> IO () +casadi__DaeBuilder__setNominal__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setNominal__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setNominal__1 :: DaeBuilderClass a => a -> String -> Double -> IO () +daeBuilder_setNominal__1 x = casadi__DaeBuilder__setNominal__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setStart__0" c_casadi__DaeBuilder__setStart__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> IO () +casadi__DaeBuilder__setStart__0 + :: DaeBuilder -> MX -> Vector Double -> IO () +casadi__DaeBuilder__setStart__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setStart__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setStart__0 :: DaeBuilderClass a => a -> MX -> Vector Double -> IO () +daeBuilder_setStart__0 x = casadi__DaeBuilder__setStart__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setStart__1" c_casadi__DaeBuilder__setStart__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__DaeBuilder__setStart__1 + :: DaeBuilder -> MX -> Vector Double -> Bool -> IO () +casadi__DaeBuilder__setStart__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setStart__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setStart__1 :: DaeBuilderClass a => a -> MX -> Vector Double -> Bool -> IO () +daeBuilder_setStart__1 x = casadi__DaeBuilder__setStart__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setStart__2" c_casadi__DaeBuilder__setStart__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> IO () +casadi__DaeBuilder__setStart__2 + :: DaeBuilder -> String -> Double -> IO () +casadi__DaeBuilder__setStart__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setStart__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setStart__2 :: DaeBuilderClass a => a -> String -> Double -> IO () +daeBuilder_setStart__2 x = casadi__DaeBuilder__setStart__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setStart__3" c_casadi__DaeBuilder__setStart__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CDouble -> CInt -> IO () +casadi__DaeBuilder__setStart__3 + :: DaeBuilder -> String -> Double -> Bool -> IO () +casadi__DaeBuilder__setStart__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setStart__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setStart__3 :: DaeBuilderClass a => a -> String -> Double -> Bool -> IO () +daeBuilder_setStart__3 x = casadi__DaeBuilder__setStart__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__setUnit" c_casadi__DaeBuilder__setUnit + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> Ptr StdString -> IO () +casadi__DaeBuilder__setUnit + :: DaeBuilder -> String -> String -> IO () +casadi__DaeBuilder__setUnit x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__setUnit errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_setUnit :: DaeBuilderClass a => a -> String -> String -> IO () +daeBuilder_setUnit x = casadi__DaeBuilder__setUnit (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__sort_alg" c_casadi__DaeBuilder__sort_alg + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__sort_alg + :: DaeBuilder -> IO () +casadi__DaeBuilder__sort_alg x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__sort_alg errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_sort_alg :: DaeBuilderClass a => a -> IO () +daeBuilder_sort_alg x = casadi__DaeBuilder__sort_alg (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__sort_d" c_casadi__DaeBuilder__sort_d + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__sort_d + :: DaeBuilder -> IO () +casadi__DaeBuilder__sort_d x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__sort_d errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_sort_d :: DaeBuilderClass a => a -> IO () +daeBuilder_sort_d x = casadi__DaeBuilder__sort_d (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__sort_dae" c_casadi__DaeBuilder__sort_dae + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__sort_dae + :: DaeBuilder -> IO () +casadi__DaeBuilder__sort_dae x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__sort_dae errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_sort_dae :: DaeBuilderClass a => a -> IO () +daeBuilder_sort_dae x = casadi__DaeBuilder__sort_dae (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__split_d" c_casadi__DaeBuilder__split_d + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__split_d + :: DaeBuilder -> IO () +casadi__DaeBuilder__split_d x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__split_d errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_split_d :: DaeBuilderClass a => a -> IO () +daeBuilder_split_d x = casadi__DaeBuilder__split_d (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__split_dae" c_casadi__DaeBuilder__split_dae + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO () +casadi__DaeBuilder__split_dae + :: DaeBuilder -> IO () +casadi__DaeBuilder__split_dae x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__split_dae errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_split_dae :: DaeBuilderClass a => a -> IO () +daeBuilder_split_dae x = casadi__DaeBuilder__split_dae (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__start__0" c_casadi__DaeBuilder__start__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__start__0 + :: DaeBuilder -> MX -> IO (Vector Double) +casadi__DaeBuilder__start__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__start__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_start__0 :: DaeBuilderClass a => a -> MX -> IO (Vector Double) +daeBuilder_start__0 x = casadi__DaeBuilder__start__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__start__1" c_casadi__DaeBuilder__start__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> CInt -> IO (Ptr (StdVec CDouble)) +casadi__DaeBuilder__start__1 + :: DaeBuilder -> MX -> Bool -> IO (Vector Double) +casadi__DaeBuilder__start__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__start__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_start__1 :: DaeBuilderClass a => a -> MX -> Bool -> IO (Vector Double) +daeBuilder_start__1 x = casadi__DaeBuilder__start__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__start__2" c_casadi__DaeBuilder__start__2 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO CDouble +casadi__DaeBuilder__start__2 + :: DaeBuilder -> String -> IO Double +casadi__DaeBuilder__start__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__start__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_start__2 :: DaeBuilderClass a => a -> String -> IO Double +daeBuilder_start__2 x = casadi__DaeBuilder__start__2 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__start__3" c_casadi__DaeBuilder__start__3 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> CInt -> IO CDouble +casadi__DaeBuilder__start__3 + :: DaeBuilder -> String -> Bool -> IO Double +casadi__DaeBuilder__start__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__start__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_start__3 :: DaeBuilderClass a => a -> String -> Bool -> IO Double +daeBuilder_start__3 x = casadi__DaeBuilder__start__3 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__unit__0" c_casadi__DaeBuilder__unit__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr MX' -> IO (Ptr StdString) +casadi__DaeBuilder__unit__0 + :: DaeBuilder -> MX -> IO String +casadi__DaeBuilder__unit__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__unit__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_unit__0 :: DaeBuilderClass a => a -> MX -> IO String +daeBuilder_unit__0 x = casadi__DaeBuilder__unit__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__unit__1" c_casadi__DaeBuilder__unit__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr StdString) +casadi__DaeBuilder__unit__1 + :: DaeBuilder -> String -> IO String +casadi__DaeBuilder__unit__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__unit__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_unit__1 :: DaeBuilderClass a => a -> String -> IO String +daeBuilder_unit__1 x = casadi__DaeBuilder__unit__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__variable__0" c_casadi__DaeBuilder__variable__0 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr Variable') +casadi__DaeBuilder__variable__0 + :: DaeBuilder -> String -> IO Variable +casadi__DaeBuilder__variable__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__variable__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_variable__0 :: DaeBuilderClass a => a -> String -> IO Variable +daeBuilder_variable__0 x = casadi__DaeBuilder__variable__0 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__variable__1" c_casadi__DaeBuilder__variable__1 + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> Ptr StdString -> IO (Ptr Variable') +casadi__DaeBuilder__variable__1 + :: DaeBuilder -> String -> IO Variable +casadi__DaeBuilder__variable__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__variable__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_variable__1 :: DaeBuilderClass a => a -> String -> IO Variable +daeBuilder_variable__1 x = casadi__DaeBuilder__variable__1 (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__getRepresentation" c_casadi__DaeBuilder__getRepresentation + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr StdString) +casadi__DaeBuilder__getRepresentation + :: DaeBuilder -> IO String +casadi__DaeBuilder__getRepresentation x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__getRepresentation errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_getRepresentation :: DaeBuilderClass a => a -> IO String +daeBuilder_getRepresentation x = casadi__DaeBuilder__getRepresentation (castDaeBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DaeBuilder__getDescription" c_casadi__DaeBuilder__getDescription + :: Ptr (Ptr StdString) -> Ptr DaeBuilder' -> IO (Ptr StdString) +casadi__DaeBuilder__getDescription + :: DaeBuilder -> IO String +casadi__DaeBuilder__getDescription x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DaeBuilder__getDescription errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +daeBuilder_getDescription :: DaeBuilderClass a => a -> IO String +daeBuilder_getDescription x = casadi__DaeBuilder__getDescription (castDaeBuilder x) + diff --git a/Casadi/Core/Classes/DerivativeGenerator.hs b/Casadi/Core/Classes/DerivativeGenerator.hs --- a/Casadi/Core/Classes/DerivativeGenerator.hs +++ b/Casadi/Core/Classes/DerivativeGenerator.hs @@ -16,6 +16,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -23,9 +24,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data diff --git a/Casadi/Core/Classes/DerivativeGenerator2.hs b/Casadi/Core/Classes/DerivativeGenerator2.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/DerivativeGenerator2.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.Core.Classes.DerivativeGenerator2 + ( + DerivativeGenerator2, + DerivativeGenerator2Class(..), + derivativeGenerator2, + derivativeGenerator2_create, + derivativeGenerator2_operator_call, + derivativeGenerator2_original, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__DerivativeGenerator2__CONSTRUCTOR" c_casadi__DerivativeGenerator2__CONSTRUCTOR + :: Ptr (Ptr StdString) -> IO (Ptr DerivativeGenerator2') +casadi__DerivativeGenerator2__CONSTRUCTOR + :: IO DerivativeGenerator2 +casadi__DerivativeGenerator2__CONSTRUCTOR = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DerivativeGenerator2__CONSTRUCTOR errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +derivativeGenerator2 :: IO DerivativeGenerator2 +derivativeGenerator2 = casadi__DerivativeGenerator2__CONSTRUCTOR + + +-- direct wrapper +foreign import ccall unsafe "casadi__DerivativeGenerator2__create" c_casadi__DerivativeGenerator2__create + :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator2' -> IO (Ptr DerivativeGenerator') +casadi__DerivativeGenerator2__create + :: DerivativeGenerator2 -> IO DerivativeGenerator +casadi__DerivativeGenerator2__create x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DerivativeGenerator2__create errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +derivativeGenerator2_create :: DerivativeGenerator2Class a => a -> IO DerivativeGenerator +derivativeGenerator2_create x = casadi__DerivativeGenerator2__create (castDerivativeGenerator2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DerivativeGenerator2__operator_call" c_casadi__DerivativeGenerator2__operator_call + :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator2' -> Ptr Function' -> CInt -> IO (Ptr Function') +casadi__DerivativeGenerator2__operator_call + :: DerivativeGenerator2 -> Function -> Int -> IO Function +casadi__DerivativeGenerator2__operator_call x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DerivativeGenerator2__operator_call errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +derivativeGenerator2_operator_call :: DerivativeGenerator2Class a => a -> Function -> Int -> IO Function +derivativeGenerator2_operator_call x = casadi__DerivativeGenerator2__operator_call (castDerivativeGenerator2 x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__DerivativeGenerator2__original" c_casadi__DerivativeGenerator2__original + :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator2' -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') +casadi__DerivativeGenerator2__original + :: DerivativeGenerator2 -> Function -> Int -> Bool -> IO Function +casadi__DerivativeGenerator2__original x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DerivativeGenerator2__original errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +derivativeGenerator2_original :: DerivativeGenerator2Class a => a -> Function -> Int -> Bool -> IO Function +derivativeGenerator2_original x = casadi__DerivativeGenerator2__original (castDerivativeGenerator2 x) + diff --git a/Casadi/Core/Classes/DleSolver.hs b/Casadi/Core/Classes/DleSolver.hs --- a/Casadi/Core/Classes/DleSolver.hs +++ b/Casadi/Core/Classes/DleSolver.hs @@ -9,9 +9,12 @@ ( DleSolver, DleSolverClass(..), - dleSolver, + dleSolver__0, + dleSolver__1, + dleSolver__2, dleSolver_clone, dleSolver_doc, + dleSolver_getSparsity, dleSolver_hasPlugin, dleSolver_loadPlugin, dleSolver_printStats, @@ -21,6 +24,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -28,31 +32,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__DleSolver__CONSTRUCTOR" c_casadi__DleSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__DleSolver__CONSTRUCTOR__0" c_casadi__DleSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr DleSolver') +casadi__DleSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO DleSolver +casadi__DleSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dleSolver__0 :: String -> String -> M.Map String Sparsity -> IO DleSolver +dleSolver__0 = casadi__DleSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DleSolver__CONSTRUCTOR__1" c_casadi__DleSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DleSolver') +casadi__DleSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO DleSolver +casadi__DleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dleSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO DleSolver +dleSolver__1 = casadi__DleSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DleSolver__CONSTRUCTOR__2" c_casadi__DleSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr DleSolver') -casadi__DleSolver__CONSTRUCTOR +casadi__DleSolver__CONSTRUCTOR__2 :: IO DleSolver -casadi__DleSolver__CONSTRUCTOR = +casadi__DleSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__DleSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__DleSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -dleSolver :: IO DleSolver -dleSolver = casadi__DleSolver__CONSTRUCTOR +dleSolver__2 :: IO DleSolver +dleSolver__2 = casadi__DleSolver__CONSTRUCTOR__2 -- direct wrapper @@ -93,6 +141,26 @@ -- classy wrapper dleSolver_doc :: String -> IO String dleSolver_doc = casadi__DleSolver__doc + + +-- direct wrapper +foreign import ccall unsafe "casadi__DleSolver__getSparsity" c_casadi__DleSolver__getSparsity + :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr Sparsity') +casadi__DleSolver__getSparsity + :: M.Map String Sparsity -> IO Sparsity +casadi__DleSolver__getSparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DleSolver__getSparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dleSolver_getSparsity :: M.Map String Sparsity -> IO Sparsity +dleSolver_getSparsity = casadi__DleSolver__getSparsity -- direct wrapper diff --git a/Casadi/Core/Classes/DpleSolver.hs b/Casadi/Core/Classes/DpleSolver.hs --- a/Casadi/Core/Classes/DpleSolver.hs +++ b/Casadi/Core/Classes/DpleSolver.hs @@ -11,6 +11,7 @@ DpleSolverClass(..), dpleSolver__0, dpleSolver__1, + dpleSolver__2, dpleSolver_clone, dpleSolver_doc, dpleSolver_hasPlugin, @@ -24,6 +25,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -31,18 +33,17 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__DpleSolver__CONSTRUCTOR__0" c_casadi__DpleSolver__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr DpleSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr DpleSolver') casadi__DpleSolver__CONSTRUCTOR__0 - :: String -> Vector Sparsity -> Vector Sparsity -> IO DpleSolver + :: String -> String -> M.Map String (Vector Sparsity) -> IO DpleSolver casadi__DpleSolver__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> @@ -56,28 +57,51 @@ -- classy wrapper -dpleSolver__0 :: String -> Vector Sparsity -> Vector Sparsity -> IO DpleSolver +dpleSolver__0 :: String -> String -> M.Map String (Vector Sparsity) -> IO DpleSolver dpleSolver__0 = casadi__DpleSolver__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__DpleSolver__CONSTRUCTOR__1" c_casadi__DpleSolver__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> IO (Ptr DpleSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DpleSolver') casadi__DpleSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO DpleSolver +casadi__DpleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__DpleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +dpleSolver__1 :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO DpleSolver +dpleSolver__1 = casadi__DpleSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__DpleSolver__CONSTRUCTOR__2" c_casadi__DpleSolver__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> IO (Ptr DpleSolver') +casadi__DpleSolver__CONSTRUCTOR__2 :: IO DpleSolver -casadi__DpleSolver__CONSTRUCTOR__1 = +casadi__DpleSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__DpleSolver__CONSTRUCTOR__1 errStrPtrP + ret <- c_casadi__DpleSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -dpleSolver__1 :: IO DpleSolver -dpleSolver__1 = casadi__DpleSolver__CONSTRUCTOR__1 +dpleSolver__2 :: IO DpleSolver +dpleSolver__2 = casadi__DpleSolver__CONSTRUCTOR__2 -- direct wrapper diff --git a/Casadi/Core/Classes/ExternalFunction.hs b/Casadi/Core/Classes/ExternalFunction.hs --- a/Casadi/Core/Classes/ExternalFunction.hs +++ b/Casadi/Core/Classes/ExternalFunction.hs @@ -11,12 +11,18 @@ ExternalFunctionClass(..), externalFunction__0, externalFunction__1, + externalFunction__2, + externalFunction__3, + externalFunction__4, + externalFunction__5, + externalFunction__6, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -24,49 +30,155 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__0" c_casadi__ExternalFunction__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr ExternalFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Compiler' -> IO (Ptr ExternalFunction') casadi__ExternalFunction__CONSTRUCTOR__0 - :: String -> IO ExternalFunction -casadi__ExternalFunction__CONSTRUCTOR__0 x0 = + :: String -> Compiler -> IO ExternalFunction +casadi__ExternalFunction__CONSTRUCTOR__0 x0 x1 = withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__ExternalFunction__CONSTRUCTOR__0 errStrPtrP x0' + ret <- c_casadi__ExternalFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -externalFunction__0 :: String -> IO ExternalFunction +externalFunction__0 :: String -> Compiler -> IO ExternalFunction externalFunction__0 = casadi__ExternalFunction__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__1" c_casadi__ExternalFunction__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> IO (Ptr ExternalFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Compiler' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ExternalFunction') casadi__ExternalFunction__CONSTRUCTOR__1 + :: String -> Compiler -> M.Map String GenericType -> IO ExternalFunction +casadi__ExternalFunction__CONSTRUCTOR__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__ExternalFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +externalFunction__1 :: String -> Compiler -> M.Map String GenericType -> IO ExternalFunction +externalFunction__1 = casadi__ExternalFunction__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__2" c_casadi__ExternalFunction__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr ExternalFunction') +casadi__ExternalFunction__CONSTRUCTOR__2 + :: String -> String -> IO ExternalFunction +casadi__ExternalFunction__CONSTRUCTOR__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__ExternalFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +externalFunction__2 :: String -> String -> IO ExternalFunction +externalFunction__2 = casadi__ExternalFunction__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__3" c_casadi__ExternalFunction__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ExternalFunction') +casadi__ExternalFunction__CONSTRUCTOR__3 + :: String -> String -> M.Map String GenericType -> IO ExternalFunction +casadi__ExternalFunction__CONSTRUCTOR__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__ExternalFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +externalFunction__3 :: String -> String -> M.Map String GenericType -> IO ExternalFunction +externalFunction__3 = casadi__ExternalFunction__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__4" c_casadi__ExternalFunction__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr ExternalFunction') +casadi__ExternalFunction__CONSTRUCTOR__4 + :: String -> IO ExternalFunction +casadi__ExternalFunction__CONSTRUCTOR__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__ExternalFunction__CONSTRUCTOR__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +externalFunction__4 :: String -> IO ExternalFunction +externalFunction__4 = casadi__ExternalFunction__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__5" c_casadi__ExternalFunction__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ExternalFunction') +casadi__ExternalFunction__CONSTRUCTOR__5 + :: String -> M.Map String GenericType -> IO ExternalFunction +casadi__ExternalFunction__CONSTRUCTOR__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__ExternalFunction__CONSTRUCTOR__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +externalFunction__5 :: String -> M.Map String GenericType -> IO ExternalFunction +externalFunction__5 = casadi__ExternalFunction__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__6" c_casadi__ExternalFunction__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> IO (Ptr ExternalFunction') +casadi__ExternalFunction__CONSTRUCTOR__6 :: IO ExternalFunction -casadi__ExternalFunction__CONSTRUCTOR__1 = +casadi__ExternalFunction__CONSTRUCTOR__6 = do errStrPtrP <- new nullPtr - ret <- c_casadi__ExternalFunction__CONSTRUCTOR__1 errStrPtrP + ret <- c_casadi__ExternalFunction__CONSTRUCTOR__6 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -externalFunction__1 :: IO ExternalFunction -externalFunction__1 = casadi__ExternalFunction__CONSTRUCTOR__1 +externalFunction__6 :: IO ExternalFunction +externalFunction__6 = casadi__ExternalFunction__CONSTRUCTOR__6 diff --git a/Casadi/Core/Classes/Function.hs b/Casadi/Core/Classes/Function.hs --- a/Casadi/Core/Classes/Function.hs +++ b/Casadi/Core/Classes/Function.hs @@ -29,3242 +29,4044 @@ function_callForward__6, function_callForward__7, function_callForward__8, - function_callParallel, - function_callReverse__0, - function_callReverse__1, - function_callReverse__2, - function_callReverse__3, - function_callReverse__4, - function_callReverse__5, - function_callReverse__6, - function_callReverse__7, - function_callReverse__8, - function_call__0, - function_call__1, - function_call__2, - function_call__3, - function_call__4, - function_call__5, - function_call__6, - function_call__7, - function_call__8, - function_checkInputs, - function_derForward, - function_derReverse, - function_derivative, - function_evaluate, - function_fullJacobian, - function_generateCodeStr__0, - function_generateCodeStr__1, - function_generateCode__0, - function_generateCode__1, - function_getInputScheme, - function_getNumInputElements, - function_getNumInputNonzeros, - function_getNumOutputElements, - function_getNumOutputNonzeros, - function_getOutputScheme, - function_getSanitizedName, - function_getStat, - function_gradient__0, - function_gradient__1, - function_gradient__2, - function_gradient__3, - function_gradient__4, - function_gradient__5, - function_gradient__6, - function_hessian__0, - function_hessian__1, - function_hessian__2, - function_hessian__3, - function_hessian__4, - function_hessian__5, - function_hessian__6, - function_inputScheme__0, - function_inputScheme__1, - function_jacSparsity__0, - function_jacSparsity__1, - function_jacSparsity__10, - function_jacSparsity__11, - function_jacSparsity__12, - function_jacSparsity__13, - function_jacSparsity__14, - function_jacSparsity__2, - function_jacSparsity__3, - function_jacSparsity__4, - function_jacSparsity__5, - function_jacSparsity__6, - function_jacSparsity__7, - function_jacSparsity__8, - function_jacSparsity__9, - function_jacobian__0, - function_jacobian__1, - function_jacobian__10, - function_jacobian__11, - function_jacobian__12, - function_jacobian__13, - function_jacobian__14, - function_jacobian__2, - function_jacobian__3, - function_jacobian__4, - function_jacobian__5, - function_jacobian__6, - function_jacobian__7, - function_jacobian__8, - function_jacobian__9, - function_operator_call__0, - function_operator_call__1, - function_operator_call__2, - function_operator_call__3, - function_operator_call__4, - function_operator_call__5, - function_operator_call__6, - function_operator_call__7, - function_operator_call__8, - function_outputScheme__0, - function_outputScheme__1, - function_removeMonitor, - function_setDerForward, - function_setDerReverse, - function_setFullJacobian, - function_setInputScheme, - function_setJacSparsity__0, - function_setJacSparsity__1, - function_setJacSparsity__2, - function_setJacSparsity__3, - function_setJacSparsity__4, - function_setJacSparsity__5, - function_setJacSparsity__6, - function_setJacSparsity__7, - function_setJacobian__0, - function_setJacobian__1, - function_setJacobian__2, - function_setJacobian__3, - function_setOutputScheme, - function_spCanEvaluate, - function_spEvaluate, - function_spInit, - function_symbolicInput, - function_symbolicInputSX, - function_tangent__0, - function_tangent__1, - function_tangent__2, - function_tangent__3, - function_tangent__4, - function_tangent__5, - function_tangent__6, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__Function__CONSTRUCTOR" c_casadi__Function__CONSTRUCTOR - :: Ptr (Ptr StdString) -> IO (Ptr Function') -casadi__Function__CONSTRUCTOR - :: IO Function -casadi__Function__CONSTRUCTOR = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__CONSTRUCTOR errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function :: IO Function -function = casadi__Function__CONSTRUCTOR - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__addMonitor" c_casadi__Function__addMonitor - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () -casadi__Function__addMonitor - :: Function -> String -> IO () -casadi__Function__addMonitor x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__addMonitor errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_addMonitor :: FunctionClass a => a -> String -> IO () -function_addMonitor x = casadi__Function__addMonitor (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__0" c_casadi__Function__call__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () -casadi__Function__call__0 - :: Function -> Vector MX -> Vector MX -> IO () -casadi__Function__call__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> IO () -function_call__0 x = casadi__Function__call__0 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__1" c_casadi__Function__call__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () -casadi__Function__call__1 - :: Function -> Vector MX -> Vector MX -> Bool -> IO () -casadi__Function__call__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> IO () -function_call__1 x = casadi__Function__call__1 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__2" c_casadi__Function__call__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO () -casadi__Function__call__2 - :: Function -> Vector MX -> Vector MX -> Bool -> Bool -> IO () -casadi__Function__call__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> Bool -> IO () -function_call__2 x = casadi__Function__call__2 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__3" c_casadi__Function__call__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () -casadi__Function__call__3 - :: Function -> Vector SX -> Vector SX -> IO () -casadi__Function__call__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> IO () -function_call__3 x = casadi__Function__call__3 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__4" c_casadi__Function__call__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO () -casadi__Function__call__4 - :: Function -> Vector SX -> Vector SX -> Bool -> IO () -casadi__Function__call__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> IO () -function_call__4 x = casadi__Function__call__4 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__5" c_casadi__Function__call__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO () -casadi__Function__call__5 - :: Function -> Vector SX -> Vector SX -> Bool -> Bool -> IO () -casadi__Function__call__5 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__5 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> Bool -> IO () -function_call__5 x = casadi__Function__call__5 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__6" c_casadi__Function__call__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO () -casadi__Function__call__6 - :: Function -> Vector DMatrix -> Vector DMatrix -> IO () -casadi__Function__call__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> IO () -function_call__6 x = casadi__Function__call__6 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__7" c_casadi__Function__call__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO () -casadi__Function__call__7 - :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () -casadi__Function__call__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () -function_call__7 x = casadi__Function__call__7 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__call__8" c_casadi__Function__call__8 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO () -casadi__Function__call__8 - :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO () -casadi__Function__call__8 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__call__8 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_call__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO () -function_call__8 x = casadi__Function__call__8 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__0" c_casadi__Function__callDerivative__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () -casadi__Function__callDerivative__0 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO () -casadi__Function__callDerivative__0 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO () -function_callDerivative__0 x = casadi__Function__callDerivative__0 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__1" c_casadi__Function__callDerivative__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () -casadi__Function__callDerivative__1 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () -casadi__Function__callDerivative__1 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () -function_callDerivative__1 x = casadi__Function__callDerivative__1 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__2" c_casadi__Function__callDerivative__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () -casadi__Function__callDerivative__2 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () -casadi__Function__callDerivative__2 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () -function_callDerivative__2 x = casadi__Function__callDerivative__2 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__3" c_casadi__Function__callDerivative__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () -casadi__Function__callDerivative__3 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO () -casadi__Function__callDerivative__3 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__3 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO () -function_callDerivative__3 x = casadi__Function__callDerivative__3 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__4" c_casadi__Function__callDerivative__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () -casadi__Function__callDerivative__4 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () -casadi__Function__callDerivative__4 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__4 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () -function_callDerivative__4 x = casadi__Function__callDerivative__4 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__5" c_casadi__Function__callDerivative__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () -casadi__Function__callDerivative__5 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () -casadi__Function__callDerivative__5 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () -function_callDerivative__5 x = casadi__Function__callDerivative__5 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__6" c_casadi__Function__callDerivative__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () -casadi__Function__callDerivative__6 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () -casadi__Function__callDerivative__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () -function_callDerivative__6 x = casadi__Function__callDerivative__6 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__7" c_casadi__Function__callDerivative__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () -casadi__Function__callDerivative__7 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () -casadi__Function__callDerivative__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () -function_callDerivative__7 x = casadi__Function__callDerivative__7 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callDerivative__8" c_casadi__Function__callDerivative__8 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () -casadi__Function__callDerivative__8 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () -casadi__Function__callDerivative__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callDerivative__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callDerivative__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () -function_callDerivative__8 x = casadi__Function__callDerivative__8 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__0" c_casadi__Function__callForward__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () -casadi__Function__callForward__0 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () -casadi__Function__callForward__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () -function_callForward__0 x = casadi__Function__callForward__0 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__1" c_casadi__Function__callForward__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () -casadi__Function__callForward__1 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () -casadi__Function__callForward__1 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__1 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () -function_callForward__1 x = casadi__Function__callForward__1 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__2" c_casadi__Function__callForward__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () -casadi__Function__callForward__2 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () -casadi__Function__callForward__2 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () -function_callForward__2 x = casadi__Function__callForward__2 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__3" c_casadi__Function__callForward__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () -casadi__Function__callForward__3 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () -casadi__Function__callForward__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () -function_callForward__3 x = casadi__Function__callForward__3 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__4" c_casadi__Function__callForward__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () -casadi__Function__callForward__4 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () -casadi__Function__callForward__4 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__4 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () -function_callForward__4 x = casadi__Function__callForward__4 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__5" c_casadi__Function__callForward__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () -casadi__Function__callForward__5 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () -casadi__Function__callForward__5 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () -function_callForward__5 x = casadi__Function__callForward__5 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__6" c_casadi__Function__callForward__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () -casadi__Function__callForward__6 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () -casadi__Function__callForward__6 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__6 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () -function_callForward__6 x = casadi__Function__callForward__6 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__7" c_casadi__Function__callForward__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () -casadi__Function__callForward__7 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () -casadi__Function__callForward__7 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__7 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () -function_callForward__7 x = casadi__Function__callForward__7 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callForward__8" c_casadi__Function__callForward__8 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () -casadi__Function__callForward__8 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () -casadi__Function__callForward__8 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callForward__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callForward__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () -function_callForward__8 x = casadi__Function__callForward__8 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callParallel" c_casadi__Function__callParallel - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -casadi__Function__callParallel - :: Function -> Vector (Vector MX) -> IO (Vector (Vector MX)) -casadi__Function__callParallel x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callParallel errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callParallel :: FunctionClass a => a -> Vector (Vector MX) -> IO (Vector (Vector MX)) -function_callParallel x = casadi__Function__callParallel (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__0" c_casadi__Function__callReverse__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () -casadi__Function__callReverse__0 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () -casadi__Function__callReverse__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () -function_callReverse__0 x = casadi__Function__callReverse__0 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__1" c_casadi__Function__callReverse__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () -casadi__Function__callReverse__1 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () -casadi__Function__callReverse__1 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__1 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () -function_callReverse__1 x = casadi__Function__callReverse__1 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__2" c_casadi__Function__callReverse__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () -casadi__Function__callReverse__2 - :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () -casadi__Function__callReverse__2 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () -function_callReverse__2 x = casadi__Function__callReverse__2 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__3" c_casadi__Function__callReverse__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () -casadi__Function__callReverse__3 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () -casadi__Function__callReverse__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () -function_callReverse__3 x = casadi__Function__callReverse__3 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__4" c_casadi__Function__callReverse__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () -casadi__Function__callReverse__4 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () -casadi__Function__callReverse__4 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__4 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () -function_callReverse__4 x = casadi__Function__callReverse__4 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__5" c_casadi__Function__callReverse__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () -casadi__Function__callReverse__5 - :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () -casadi__Function__callReverse__5 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () -function_callReverse__5 x = casadi__Function__callReverse__5 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__6" c_casadi__Function__callReverse__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () -casadi__Function__callReverse__6 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () -casadi__Function__callReverse__6 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__6 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () -function_callReverse__6 x = casadi__Function__callReverse__6 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__7" c_casadi__Function__callReverse__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () -casadi__Function__callReverse__7 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () -casadi__Function__callReverse__7 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__7 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () -function_callReverse__7 x = casadi__Function__callReverse__7 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__callReverse__8" c_casadi__Function__callReverse__8 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () -casadi__Function__callReverse__8 - :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () -casadi__Function__callReverse__8 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__callReverse__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_callReverse__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () -function_callReverse__8 x = casadi__Function__callReverse__8 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__checkInputs" c_casadi__Function__checkInputs - :: Ptr (Ptr StdString) -> Ptr Function' -> IO () -casadi__Function__checkInputs - :: Function -> IO () -casadi__Function__checkInputs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__checkInputs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_checkInputs :: FunctionClass a => a -> IO () -function_checkInputs x = casadi__Function__checkInputs (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__derForward" c_casadi__Function__derForward - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') -casadi__Function__derForward - :: Function -> Int -> IO Function -casadi__Function__derForward x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__derForward errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_derForward :: FunctionClass a => a -> Int -> IO Function -function_derForward x = casadi__Function__derForward (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__derReverse" c_casadi__Function__derReverse - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') -casadi__Function__derReverse - :: Function -> Int -> IO Function -casadi__Function__derReverse x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__derReverse errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_derReverse :: FunctionClass a => a -> Int -> IO Function -function_derReverse x = casadi__Function__derReverse (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__derivative" c_casadi__Function__derivative - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__derivative - :: Function -> Int -> Int -> IO Function -casadi__Function__derivative x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__derivative errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_derivative :: FunctionClass a => a -> Int -> Int -> IO Function -function_derivative x = casadi__Function__derivative (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__evaluate" c_casadi__Function__evaluate - :: Ptr (Ptr StdString) -> Ptr Function' -> IO () -casadi__Function__evaluate - :: Function -> IO () -casadi__Function__evaluate x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__evaluate errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_evaluate :: FunctionClass a => a -> IO () -function_evaluate x = casadi__Function__evaluate (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__fullJacobian" c_casadi__Function__fullJacobian - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') -casadi__Function__fullJacobian - :: Function -> IO Function -casadi__Function__fullJacobian x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__fullJacobian errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_fullJacobian :: FunctionClass a => a -> IO Function -function_fullJacobian x = casadi__Function__fullJacobian (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__generateCode__0" c_casadi__Function__generateCode__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () -casadi__Function__generateCode__0 - :: Function -> String -> IO () -casadi__Function__generateCode__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__generateCode__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_generateCode__0 :: FunctionClass a => a -> String -> IO () -function_generateCode__0 x = casadi__Function__generateCode__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__generateCode__1" c_casadi__Function__generateCode__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO () -casadi__Function__generateCode__1 - :: Function -> String -> Bool -> IO () -casadi__Function__generateCode__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__generateCode__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_generateCode__1 :: FunctionClass a => a -> String -> Bool -> IO () -function_generateCode__1 x = casadi__Function__generateCode__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__generateCodeStr__0" c_casadi__Function__generateCodeStr__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString) -casadi__Function__generateCodeStr__0 - :: Function -> IO String -casadi__Function__generateCodeStr__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__generateCodeStr__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_generateCodeStr__0 :: FunctionClass a => a -> IO String -function_generateCodeStr__0 x = casadi__Function__generateCodeStr__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__generateCodeStr__1" c_casadi__Function__generateCodeStr__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) -casadi__Function__generateCodeStr__1 - :: Function -> Bool -> IO String -casadi__Function__generateCodeStr__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__generateCodeStr__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_generateCodeStr__1 :: FunctionClass a => a -> Bool -> IO String -function_generateCodeStr__1 x = casadi__Function__generateCodeStr__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getInputScheme" c_casadi__Function__getInputScheme - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme') -casadi__Function__getInputScheme - :: Function -> IO IOScheme -casadi__Function__getInputScheme x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getInputScheme errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getInputScheme :: FunctionClass a => a -> IO IOScheme -function_getInputScheme x = casadi__Function__getInputScheme (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getNumInputElements" c_casadi__Function__getNumInputElements - :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt -casadi__Function__getNumInputElements - :: Function -> IO Int -casadi__Function__getNumInputElements x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getNumInputElements errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getNumInputElements :: FunctionClass a => a -> IO Int -function_getNumInputElements x = casadi__Function__getNumInputElements (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getNumInputNonzeros" c_casadi__Function__getNumInputNonzeros - :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt -casadi__Function__getNumInputNonzeros - :: Function -> IO Int -casadi__Function__getNumInputNonzeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getNumInputNonzeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getNumInputNonzeros :: FunctionClass a => a -> IO Int -function_getNumInputNonzeros x = casadi__Function__getNumInputNonzeros (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getNumOutputElements" c_casadi__Function__getNumOutputElements - :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt -casadi__Function__getNumOutputElements - :: Function -> IO Int -casadi__Function__getNumOutputElements x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getNumOutputElements errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getNumOutputElements :: FunctionClass a => a -> IO Int -function_getNumOutputElements x = casadi__Function__getNumOutputElements (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getNumOutputNonzeros" c_casadi__Function__getNumOutputNonzeros - :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt -casadi__Function__getNumOutputNonzeros - :: Function -> IO Int -casadi__Function__getNumOutputNonzeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getNumOutputNonzeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getNumOutputNonzeros :: FunctionClass a => a -> IO Int -function_getNumOutputNonzeros x = casadi__Function__getNumOutputNonzeros (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getOutputScheme" c_casadi__Function__getOutputScheme - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme') -casadi__Function__getOutputScheme - :: Function -> IO IOScheme -casadi__Function__getOutputScheme x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getOutputScheme errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getOutputScheme :: FunctionClass a => a -> IO IOScheme -function_getOutputScheme x = casadi__Function__getOutputScheme (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getSanitizedName" c_casadi__Function__getSanitizedName - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString) -casadi__Function__getSanitizedName - :: Function -> IO String -casadi__Function__getSanitizedName x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getSanitizedName errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getSanitizedName :: FunctionClass a => a -> IO String -function_getSanitizedName x = casadi__Function__getSanitizedName (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__getStat" c_casadi__Function__getStat - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr GenericType') -casadi__Function__getStat - :: Function -> String -> IO GenericType -casadi__Function__getStat x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__getStat errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_getStat :: FunctionClass a => a -> String -> IO GenericType -function_getStat x = casadi__Function__getStat (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__gradient__0" c_casadi__Function__gradient__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') -casadi__Function__gradient__0 - :: Function -> String -> String -> IO Function -casadi__Function__gradient__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__gradient__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_gradient__0 :: FunctionClass a => a -> String -> String -> IO Function -function_gradient__0 x = casadi__Function__gradient__0 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__gradient__1" c_casadi__Function__gradient__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') -casadi__Function__gradient__1 - :: Function -> Int -> String -> IO Function -casadi__Function__gradient__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__gradient__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_gradient__1 :: FunctionClass a => a -> Int -> String -> IO Function -function_gradient__1 x = casadi__Function__gradient__1 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__gradient__2" c_casadi__Function__gradient__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') -casadi__Function__gradient__2 - :: Function -> String -> IO Function -casadi__Function__gradient__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__gradient__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_gradient__2 :: FunctionClass a => a -> String -> IO Function -function_gradient__2 x = casadi__Function__gradient__2 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__gradient__3" c_casadi__Function__gradient__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') -casadi__Function__gradient__3 - :: Function -> String -> Int -> IO Function -casadi__Function__gradient__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__gradient__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_gradient__3 :: FunctionClass a => a -> String -> Int -> IO Function -function_gradient__3 x = casadi__Function__gradient__3 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__gradient__4" c_casadi__Function__gradient__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') -casadi__Function__gradient__4 - :: Function -> IO Function -casadi__Function__gradient__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__gradient__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_gradient__4 :: FunctionClass a => a -> IO Function -function_gradient__4 x = casadi__Function__gradient__4 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__gradient__5" c_casadi__Function__gradient__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') -casadi__Function__gradient__5 - :: Function -> Int -> IO Function -casadi__Function__gradient__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__gradient__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_gradient__5 :: FunctionClass a => a -> Int -> IO Function -function_gradient__5 x = casadi__Function__gradient__5 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__gradient__6" c_casadi__Function__gradient__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__gradient__6 - :: Function -> Int -> Int -> IO Function -casadi__Function__gradient__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__gradient__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_gradient__6 :: FunctionClass a => a -> Int -> Int -> IO Function -function_gradient__6 x = casadi__Function__gradient__6 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__hessian__0" c_casadi__Function__hessian__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') -casadi__Function__hessian__0 - :: Function -> String -> String -> IO Function -casadi__Function__hessian__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__hessian__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_hessian__0 :: FunctionClass a => a -> String -> String -> IO Function -function_hessian__0 x = casadi__Function__hessian__0 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__hessian__1" c_casadi__Function__hessian__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') -casadi__Function__hessian__1 - :: Function -> Int -> String -> IO Function -casadi__Function__hessian__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__hessian__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_hessian__1 :: FunctionClass a => a -> Int -> String -> IO Function -function_hessian__1 x = casadi__Function__hessian__1 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__hessian__2" c_casadi__Function__hessian__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') -casadi__Function__hessian__2 - :: Function -> String -> IO Function -casadi__Function__hessian__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__hessian__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_hessian__2 :: FunctionClass a => a -> String -> IO Function -function_hessian__2 x = casadi__Function__hessian__2 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__hessian__3" c_casadi__Function__hessian__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') -casadi__Function__hessian__3 - :: Function -> String -> Int -> IO Function -casadi__Function__hessian__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__hessian__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_hessian__3 :: FunctionClass a => a -> String -> Int -> IO Function -function_hessian__3 x = casadi__Function__hessian__3 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__hessian__4" c_casadi__Function__hessian__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') -casadi__Function__hessian__4 - :: Function -> IO Function -casadi__Function__hessian__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__hessian__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_hessian__4 :: FunctionClass a => a -> IO Function -function_hessian__4 x = casadi__Function__hessian__4 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__hessian__5" c_casadi__Function__hessian__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') -casadi__Function__hessian__5 - :: Function -> Int -> IO Function -casadi__Function__hessian__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__hessian__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_hessian__5 :: FunctionClass a => a -> Int -> IO Function -function_hessian__5 x = casadi__Function__hessian__5 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__hessian__6" c_casadi__Function__hessian__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__hessian__6 - :: Function -> Int -> Int -> IO Function -casadi__Function__hessian__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__hessian__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_hessian__6 :: FunctionClass a => a -> Int -> Int -> IO Function -function_hessian__6 x = casadi__Function__hessian__6 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__inputScheme__0" c_casadi__Function__inputScheme__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme') -casadi__Function__inputScheme__0 - :: Function -> IO IOScheme -casadi__Function__inputScheme__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__inputScheme__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_inputScheme__0 :: FunctionClass a => a -> IO IOScheme -function_inputScheme__0 x = casadi__Function__inputScheme__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__inputScheme__1" c_casadi__Function__inputScheme__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme') -casadi__Function__inputScheme__1 - :: Function -> IO IOScheme -casadi__Function__inputScheme__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__inputScheme__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_inputScheme__1 :: FunctionClass a => a -> IO IOScheme -function_inputScheme__1 x = casadi__Function__inputScheme__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__0" c_casadi__Function__jacSparsity__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__0 - :: Function -> String -> String -> IO Sparsity -casadi__Function__jacSparsity__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__0 :: FunctionClass a => a -> String -> String -> IO Sparsity -function_jacSparsity__0 x = casadi__Function__jacSparsity__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__1" c_casadi__Function__jacSparsity__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__1 - :: Function -> String -> String -> Bool -> IO Sparsity -casadi__Function__jacSparsity__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Sparsity -function_jacSparsity__1 x = casadi__Function__jacSparsity__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__2" c_casadi__Function__jacSparsity__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__2 - :: Function -> String -> String -> Bool -> Bool -> IO Sparsity -casadi__Function__jacSparsity__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Sparsity -function_jacSparsity__2 x = casadi__Function__jacSparsity__2 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__3" c_casadi__Function__jacSparsity__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__3 - :: Function -> Int -> String -> IO Sparsity -casadi__Function__jacSparsity__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__3 :: FunctionClass a => a -> Int -> String -> IO Sparsity -function_jacSparsity__3 x = casadi__Function__jacSparsity__3 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__4" c_casadi__Function__jacSparsity__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__4 - :: Function -> Int -> String -> Bool -> IO Sparsity -casadi__Function__jacSparsity__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Sparsity -function_jacSparsity__4 x = casadi__Function__jacSparsity__4 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__5" c_casadi__Function__jacSparsity__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__5 - :: Function -> Int -> String -> Bool -> Bool -> IO Sparsity -casadi__Function__jacSparsity__5 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__5 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Sparsity -function_jacSparsity__5 x = casadi__Function__jacSparsity__5 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__6" c_casadi__Function__jacSparsity__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__6 - :: Function -> String -> IO Sparsity -casadi__Function__jacSparsity__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__6 :: FunctionClass a => a -> String -> IO Sparsity -function_jacSparsity__6 x = casadi__Function__jacSparsity__6 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__7" c_casadi__Function__jacSparsity__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__7 - :: Function -> String -> Int -> IO Sparsity -casadi__Function__jacSparsity__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__7 :: FunctionClass a => a -> String -> Int -> IO Sparsity -function_jacSparsity__7 x = casadi__Function__jacSparsity__7 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__8" c_casadi__Function__jacSparsity__8 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__8 - :: Function -> String -> Int -> Bool -> IO Sparsity -casadi__Function__jacSparsity__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Sparsity -function_jacSparsity__8 x = casadi__Function__jacSparsity__8 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__9" c_casadi__Function__jacSparsity__9 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__9 - :: Function -> String -> Int -> Bool -> Bool -> IO Sparsity -casadi__Function__jacSparsity__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Sparsity -function_jacSparsity__9 x = casadi__Function__jacSparsity__9 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__10" c_casadi__Function__jacSparsity__10 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__10 - :: Function -> IO Sparsity -casadi__Function__jacSparsity__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__10 :: FunctionClass a => a -> IO Sparsity -function_jacSparsity__10 x = casadi__Function__jacSparsity__10 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__11" c_casadi__Function__jacSparsity__11 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__11 - :: Function -> Int -> IO Sparsity -casadi__Function__jacSparsity__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__11 :: FunctionClass a => a -> Int -> IO Sparsity -function_jacSparsity__11 x = casadi__Function__jacSparsity__11 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__12" c_casadi__Function__jacSparsity__12 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__12 - :: Function -> Int -> Int -> IO Sparsity -casadi__Function__jacSparsity__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__12 :: FunctionClass a => a -> Int -> Int -> IO Sparsity -function_jacSparsity__12 x = casadi__Function__jacSparsity__12 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__13" c_casadi__Function__jacSparsity__13 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__13 - :: Function -> Int -> Int -> Bool -> IO Sparsity -casadi__Function__jacSparsity__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Sparsity -function_jacSparsity__13 x = casadi__Function__jacSparsity__13 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__jacSparsity__14" c_casadi__Function__jacSparsity__14 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Function__jacSparsity__14 - :: Function -> Int -> Int -> Bool -> Bool -> IO Sparsity -casadi__Function__jacSparsity__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacSparsity__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacSparsity__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Sparsity -function_jacSparsity__14 x = casadi__Function__jacSparsity__14 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__0" c_casadi__Function__jacobian__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') -casadi__Function__jacobian__0 - :: Function -> String -> String -> IO Function -casadi__Function__jacobian__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__0 :: FunctionClass a => a -> String -> String -> IO Function -function_jacobian__0 x = casadi__Function__jacobian__0 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__1" c_casadi__Function__jacobian__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__1 - :: Function -> String -> String -> Bool -> IO Function -casadi__Function__jacobian__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Function -function_jacobian__1 x = casadi__Function__jacobian__1 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__2" c_casadi__Function__jacobian__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__2 - :: Function -> String -> String -> Bool -> Bool -> IO Function -casadi__Function__jacobian__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Function -function_jacobian__2 x = casadi__Function__jacobian__2 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__3" c_casadi__Function__jacobian__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') -casadi__Function__jacobian__3 - :: Function -> Int -> String -> IO Function -casadi__Function__jacobian__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__3 :: FunctionClass a => a -> Int -> String -> IO Function -function_jacobian__3 x = casadi__Function__jacobian__3 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__4" c_casadi__Function__jacobian__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__4 - :: Function -> Int -> String -> Bool -> IO Function -casadi__Function__jacobian__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Function -function_jacobian__4 x = casadi__Function__jacobian__4 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__5" c_casadi__Function__jacobian__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__5 - :: Function -> Int -> String -> Bool -> Bool -> IO Function -casadi__Function__jacobian__5 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__5 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Function -function_jacobian__5 x = casadi__Function__jacobian__5 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__6" c_casadi__Function__jacobian__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') -casadi__Function__jacobian__6 - :: Function -> String -> IO Function -casadi__Function__jacobian__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__6 :: FunctionClass a => a -> String -> IO Function -function_jacobian__6 x = casadi__Function__jacobian__6 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__7" c_casadi__Function__jacobian__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__7 - :: Function -> String -> Int -> IO Function -casadi__Function__jacobian__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__7 :: FunctionClass a => a -> String -> Int -> IO Function -function_jacobian__7 x = casadi__Function__jacobian__7 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__8" c_casadi__Function__jacobian__8 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__8 - :: Function -> String -> Int -> Bool -> IO Function -casadi__Function__jacobian__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Function -function_jacobian__8 x = casadi__Function__jacobian__8 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__9" c_casadi__Function__jacobian__9 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__9 - :: Function -> String -> Int -> Bool -> Bool -> IO Function -casadi__Function__jacobian__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Function -function_jacobian__9 x = casadi__Function__jacobian__9 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__10" c_casadi__Function__jacobian__10 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') -casadi__Function__jacobian__10 - :: Function -> IO Function -casadi__Function__jacobian__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__10 :: FunctionClass a => a -> IO Function -function_jacobian__10 x = casadi__Function__jacobian__10 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__11" c_casadi__Function__jacobian__11 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__11 - :: Function -> Int -> IO Function -casadi__Function__jacobian__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__11 :: FunctionClass a => a -> Int -> IO Function -function_jacobian__11 x = casadi__Function__jacobian__11 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__12" c_casadi__Function__jacobian__12 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__12 - :: Function -> Int -> Int -> IO Function -casadi__Function__jacobian__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__12 :: FunctionClass a => a -> Int -> Int -> IO Function -function_jacobian__12 x = casadi__Function__jacobian__12 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__13" c_casadi__Function__jacobian__13 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__13 - :: Function -> Int -> Int -> Bool -> IO Function -casadi__Function__jacobian__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Function -function_jacobian__13 x = casadi__Function__jacobian__13 (castFunction x) - - --- direct wrapper -foreign import ccall safe "casadi__Function__jacobian__14" c_casadi__Function__jacobian__14 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Function') -casadi__Function__jacobian__14 - :: Function -> Int -> Int -> Bool -> Bool -> IO Function -casadi__Function__jacobian__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__jacobian__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_jacobian__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Function -function_jacobian__14 x = casadi__Function__jacobian__14 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__0" c_casadi__Function__operator_call__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__Function__operator_call__0 - :: Function -> Vector MX -> IO (Vector MX) -casadi__Function__operator_call__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__0 :: FunctionClass a => a -> Vector MX -> IO (Vector MX) -function_operator_call__0 x = casadi__Function__operator_call__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__1" c_casadi__Function__operator_call__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec (Ptr MX'))) -casadi__Function__operator_call__1 - :: Function -> Vector MX -> Bool -> IO (Vector MX) -casadi__Function__operator_call__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__1 :: FunctionClass a => a -> Vector MX -> Bool -> IO (Vector MX) -function_operator_call__1 x = casadi__Function__operator_call__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__2" c_casadi__Function__operator_call__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX'))) -casadi__Function__operator_call__2 - :: Function -> Vector MX -> Bool -> Bool -> IO (Vector MX) -casadi__Function__operator_call__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__2 :: FunctionClass a => a -> Vector MX -> Bool -> Bool -> IO (Vector MX) -function_operator_call__2 x = casadi__Function__operator_call__2 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__3" c_casadi__Function__operator_call__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -casadi__Function__operator_call__3 - :: Function -> Vector SX -> IO (Vector SX) -casadi__Function__operator_call__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__3 :: FunctionClass a => a -> Vector SX -> IO (Vector SX) -function_operator_call__3 x = casadi__Function__operator_call__3 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__4" c_casadi__Function__operator_call__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec (Ptr SX'))) -casadi__Function__operator_call__4 - :: Function -> Vector SX -> Bool -> IO (Vector SX) -casadi__Function__operator_call__4 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__4 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__4 :: FunctionClass a => a -> Vector SX -> Bool -> IO (Vector SX) -function_operator_call__4 x = casadi__Function__operator_call__4 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__5" c_casadi__Function__operator_call__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX'))) -casadi__Function__operator_call__5 - :: Function -> Vector SX -> Bool -> Bool -> IO (Vector SX) -casadi__Function__operator_call__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__5 :: FunctionClass a => a -> Vector SX -> Bool -> Bool -> IO (Vector SX) -function_operator_call__5 x = casadi__Function__operator_call__5 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__6" c_casadi__Function__operator_call__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__Function__operator_call__6 - :: Function -> Vector DMatrix -> IO (Vector DMatrix) -casadi__Function__operator_call__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__6 :: FunctionClass a => a -> Vector DMatrix -> IO (Vector DMatrix) -function_operator_call__6 x = casadi__Function__operator_call__6 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__7" c_casadi__Function__operator_call__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__Function__operator_call__7 - :: Function -> Vector DMatrix -> Bool -> IO (Vector DMatrix) -casadi__Function__operator_call__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__7 :: FunctionClass a => a -> Vector DMatrix -> Bool -> IO (Vector DMatrix) -function_operator_call__7 x = casadi__Function__operator_call__7 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__operator_call__8" c_casadi__Function__operator_call__8 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) -casadi__Function__operator_call__8 - :: Function -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix) -casadi__Function__operator_call__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__operator_call__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_operator_call__8 :: FunctionClass a => a -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix) -function_operator_call__8 x = casadi__Function__operator_call__8 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__outputScheme__0" c_casadi__Function__outputScheme__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme') -casadi__Function__outputScheme__0 - :: Function -> IO IOScheme -casadi__Function__outputScheme__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__outputScheme__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_outputScheme__0 :: FunctionClass a => a -> IO IOScheme -function_outputScheme__0 x = casadi__Function__outputScheme__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__outputScheme__1" c_casadi__Function__outputScheme__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr IOScheme') -casadi__Function__outputScheme__1 - :: Function -> IO IOScheme -casadi__Function__outputScheme__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__outputScheme__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_outputScheme__1 :: FunctionClass a => a -> IO IOScheme -function_outputScheme__1 x = casadi__Function__outputScheme__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__removeMonitor" c_casadi__Function__removeMonitor - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () -casadi__Function__removeMonitor - :: Function -> String -> IO () -casadi__Function__removeMonitor x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__removeMonitor errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_removeMonitor :: FunctionClass a => a -> String -> IO () -function_removeMonitor x = casadi__Function__removeMonitor (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setDerForward" c_casadi__Function__setDerForward - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () -casadi__Function__setDerForward - :: Function -> Function -> Int -> IO () -casadi__Function__setDerForward x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setDerForward errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setDerForward :: FunctionClass a => a -> Function -> Int -> IO () -function_setDerForward x = casadi__Function__setDerForward (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setDerReverse" c_casadi__Function__setDerReverse - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () -casadi__Function__setDerReverse - :: Function -> Function -> Int -> IO () -casadi__Function__setDerReverse x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setDerReverse errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setDerReverse :: FunctionClass a => a -> Function -> Int -> IO () -function_setDerReverse x = casadi__Function__setDerReverse (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setFullJacobian" c_casadi__Function__setFullJacobian - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO () -casadi__Function__setFullJacobian - :: Function -> Function -> IO () -casadi__Function__setFullJacobian x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setFullJacobian errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setFullJacobian :: FunctionClass a => a -> Function -> IO () -function_setFullJacobian x = casadi__Function__setFullJacobian (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setInputScheme" c_casadi__Function__setInputScheme - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr IOScheme' -> IO () -casadi__Function__setInputScheme - :: Function -> IOScheme -> IO () -casadi__Function__setInputScheme x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setInputScheme errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setInputScheme :: FunctionClass a => a -> IOScheme -> IO () -function_setInputScheme x = casadi__Function__setInputScheme (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__0" c_casadi__Function__setJacSparsity__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> IO () -casadi__Function__setJacSparsity__0 - :: Function -> Sparsity -> String -> String -> IO () -casadi__Function__setJacSparsity__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__0 :: FunctionClass a => a -> Sparsity -> String -> String -> IO () -function_setJacSparsity__0 x = casadi__Function__setJacSparsity__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__1" c_casadi__Function__setJacSparsity__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> CInt -> IO () -casadi__Function__setJacSparsity__1 - :: Function -> Sparsity -> String -> String -> Bool -> IO () -casadi__Function__setJacSparsity__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__1 :: FunctionClass a => a -> Sparsity -> String -> String -> Bool -> IO () -function_setJacSparsity__1 x = casadi__Function__setJacSparsity__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__2" c_casadi__Function__setJacSparsity__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> IO () -casadi__Function__setJacSparsity__2 - :: Function -> Sparsity -> Int -> String -> IO () -casadi__Function__setJacSparsity__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__2 :: FunctionClass a => a -> Sparsity -> Int -> String -> IO () -function_setJacSparsity__2 x = casadi__Function__setJacSparsity__2 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__3" c_casadi__Function__setJacSparsity__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> CInt -> IO () -casadi__Function__setJacSparsity__3 - :: Function -> Sparsity -> Int -> String -> Bool -> IO () -casadi__Function__setJacSparsity__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__3 :: FunctionClass a => a -> Sparsity -> Int -> String -> Bool -> IO () -function_setJacSparsity__3 x = casadi__Function__setJacSparsity__3 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__4" c_casadi__Function__setJacSparsity__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> IO () -casadi__Function__setJacSparsity__4 - :: Function -> Sparsity -> String -> Int -> IO () -casadi__Function__setJacSparsity__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__4 :: FunctionClass a => a -> Sparsity -> String -> Int -> IO () -function_setJacSparsity__4 x = casadi__Function__setJacSparsity__4 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__5" c_casadi__Function__setJacSparsity__5 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> CInt -> IO () -casadi__Function__setJacSparsity__5 - :: Function -> Sparsity -> String -> Int -> Bool -> IO () -casadi__Function__setJacSparsity__5 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__5 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__5 :: FunctionClass a => a -> Sparsity -> String -> Int -> Bool -> IO () -function_setJacSparsity__5 x = casadi__Function__setJacSparsity__5 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__6" c_casadi__Function__setJacSparsity__6 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> IO () -casadi__Function__setJacSparsity__6 - :: Function -> Sparsity -> Int -> Int -> IO () -casadi__Function__setJacSparsity__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__6 :: FunctionClass a => a -> Sparsity -> Int -> Int -> IO () -function_setJacSparsity__6 x = casadi__Function__setJacSparsity__6 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacSparsity__7" c_casadi__Function__setJacSparsity__7 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> CInt -> IO () -casadi__Function__setJacSparsity__7 - :: Function -> Sparsity -> Int -> Int -> Bool -> IO () -casadi__Function__setJacSparsity__7 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacSparsity__7 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacSparsity__7 :: FunctionClass a => a -> Sparsity -> Int -> Int -> Bool -> IO () -function_setJacSparsity__7 x = casadi__Function__setJacSparsity__7 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacobian__0" c_casadi__Function__setJacobian__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO () -casadi__Function__setJacobian__0 - :: Function -> Function -> IO () -casadi__Function__setJacobian__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacobian__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacobian__0 :: FunctionClass a => a -> Function -> IO () -function_setJacobian__0 x = casadi__Function__setJacobian__0 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacobian__1" c_casadi__Function__setJacobian__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () -casadi__Function__setJacobian__1 - :: Function -> Function -> Int -> IO () -casadi__Function__setJacobian__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacobian__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacobian__1 :: FunctionClass a => a -> Function -> Int -> IO () -function_setJacobian__1 x = casadi__Function__setJacobian__1 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacobian__2" c_casadi__Function__setJacobian__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> IO () -casadi__Function__setJacobian__2 - :: Function -> Function -> Int -> Int -> IO () -casadi__Function__setJacobian__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacobian__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacobian__2 :: FunctionClass a => a -> Function -> Int -> Int -> IO () -function_setJacobian__2 x = casadi__Function__setJacobian__2 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setJacobian__3" c_casadi__Function__setJacobian__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> CInt -> IO () -casadi__Function__setJacobian__3 - :: Function -> Function -> Int -> Int -> Bool -> IO () -casadi__Function__setJacobian__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setJacobian__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setJacobian__3 :: FunctionClass a => a -> Function -> Int -> Int -> Bool -> IO () -function_setJacobian__3 x = casadi__Function__setJacobian__3 (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__setOutputScheme" c_casadi__Function__setOutputScheme - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr IOScheme' -> IO () -casadi__Function__setOutputScheme - :: Function -> IOScheme -> IO () -casadi__Function__setOutputScheme x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__setOutputScheme errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_setOutputScheme :: FunctionClass a => a -> IOScheme -> IO () -function_setOutputScheme x = casadi__Function__setOutputScheme (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__spCanEvaluate" c_casadi__Function__spCanEvaluate - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt -casadi__Function__spCanEvaluate - :: Function -> Bool -> IO Bool -casadi__Function__spCanEvaluate x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__spCanEvaluate errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_spCanEvaluate :: FunctionClass a => a -> Bool -> IO Bool -function_spCanEvaluate x = casadi__Function__spCanEvaluate (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__spEvaluate" c_casadi__Function__spEvaluate - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO () -casadi__Function__spEvaluate - :: Function -> Bool -> IO () -casadi__Function__spEvaluate x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__spEvaluate errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_spEvaluate :: FunctionClass a => a -> Bool -> IO () -function_spEvaluate x = casadi__Function__spEvaluate (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__spInit" c_casadi__Function__spInit - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO () -casadi__Function__spInit - :: Function -> Bool -> IO () -casadi__Function__spInit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__spInit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_spInit :: FunctionClass a => a -> Bool -> IO () -function_spInit x = casadi__Function__spInit (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__symbolicInput" c_casadi__Function__symbolicInput - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX'))) -casadi__Function__symbolicInput - :: Function -> IO (Vector MX) -casadi__Function__symbolicInput x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__symbolicInput errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_symbolicInput :: FunctionClass a => a -> IO (Vector MX) -function_symbolicInput x = casadi__Function__symbolicInput (castFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Function__symbolicInputSX" c_casadi__Function__symbolicInputSX - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX'))) -casadi__Function__symbolicInputSX - :: Function -> IO (Vector SX) -casadi__Function__symbolicInputSX x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Function__symbolicInputSX errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_symbolicInputSX :: FunctionClass a => a -> IO (Vector SX) -function_symbolicInputSX x = casadi__Function__symbolicInputSX (castFunction x) + function_callReverse__0, + function_callReverse__1, + function_callReverse__2, + function_callReverse__3, + function_callReverse__4, + function_callReverse__5, + function_callReverse__6, + function_callReverse__7, + function_callReverse__8, + function_call__0, + function_call__1, + function_call__2, + function_call__3, + function_call__4, + function_call__5, + function_call__6, + function_call__7, + function_call__8, + function_checkInputs, + function_defaultInput, + function_derForward, + function_derReverse, + function_derivative, + function_evaluate, + function_fullJacobian, + function_generate__0, + function_generate__1, + function_generate__2, + function_generate__3, + function_getSanitizedName, + function_getStat, + function_getStats, + function_gradient__0, + function_gradient__1, + function_gradient__2, + function_gradient__3, + function_gradient__4, + function_gradient__5, + function_gradient__6, + function_hessian__0, + function_hessian__1, + function_hessian__2, + function_hessian__3, + function_hessian__4, + function_hessian__5, + function_hessian__6, + function_inputDescription, + function_inputIndex, + function_inputName, + function_inputScheme, + function_inputSparsity__0, + function_inputSparsity__1, + function_inputSparsity__2, + function_jacSparsity__0, + function_jacSparsity__1, + function_jacSparsity__10, + function_jacSparsity__11, + function_jacSparsity__12, + function_jacSparsity__13, + function_jacSparsity__14, + function_jacSparsity__2, + function_jacSparsity__3, + function_jacSparsity__4, + function_jacSparsity__5, + function_jacSparsity__6, + function_jacSparsity__7, + function_jacSparsity__8, + function_jacSparsity__9, + function_jacobian__0, + function_jacobian__1, + function_jacobian__10, + function_jacobian__11, + function_jacobian__12, + function_jacobian__13, + function_jacobian__14, + function_jacobian__2, + function_jacobian__3, + function_jacobian__4, + function_jacobian__5, + function_jacobian__6, + function_jacobian__7, + function_jacobian__8, + function_jacobian__9, + function_map__0, + function_map__1, + function_map__2, + function_map__3, + function_map__4, + function_map__5, + function_mapaccum__0, + function_mapaccum__1, + function_mapsum__0, + function_mapsum__1, + function_nIn, + function_nOut, + function_nnzIn, + function_nnzOut, + function_numelIn, + function_numelOut, + function_operator_call__0, + function_operator_call__1, + function_operator_call__10, + function_operator_call__11, + function_operator_call__12, + function_operator_call__13, + function_operator_call__14, + function_operator_call__15, + function_operator_call__16, + function_operator_call__17, + function_operator_call__2, + function_operator_call__3, + function_operator_call__4, + function_operator_call__5, + function_operator_call__6, + function_operator_call__7, + function_operator_call__8, + function_operator_call__9, + function_outputDescription, + function_outputIndex, + function_outputName, + function_outputScheme, + function_outputSparsity__0, + function_outputSparsity__1, + function_outputSparsity__2, + function_printDimensions, + function_removeMonitor, + function_sanitizeName, + function_setDerForward, + function_setDerReverse, + function_setFullJacobian, + function_setJacSparsity__0, + function_setJacSparsity__1, + function_setJacSparsity__2, + function_setJacSparsity__3, + function_setJacSparsity__4, + function_setJacSparsity__5, + function_setJacSparsity__6, + function_setJacSparsity__7, + function_setJacobian__0, + function_setJacobian__1, + function_setJacobian__2, + function_setJacobian__3, + function_spCanEvaluate, + function_spEvaluate, + function_spInit, + function_symbolicInputSX, + function_symbolicInput__0, + function_symbolicInput__1, + function_symbolicOutput, + function_sz_arg, + function_sz_iw, + function_sz_res, + function_sz_w, + function_tangent__0, + function_tangent__1, + function_tangent__2, + function_tangent__3, + function_tangent__4, + function_tangent__5, + function_tangent__6, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__Function__CONSTRUCTOR" c_casadi__Function__CONSTRUCTOR + :: Ptr (Ptr StdString) -> IO (Ptr Function') +casadi__Function__CONSTRUCTOR + :: IO Function +casadi__Function__CONSTRUCTOR = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__CONSTRUCTOR errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function :: IO Function +function = casadi__Function__CONSTRUCTOR + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__addMonitor" c_casadi__Function__addMonitor + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () +casadi__Function__addMonitor + :: Function -> String -> IO () +casadi__Function__addMonitor x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__addMonitor errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_addMonitor :: FunctionClass a => a -> String -> IO () +function_addMonitor x = casadi__Function__addMonitor (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__0" c_casadi__Function__call__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () +casadi__Function__call__0 + :: Function -> Vector MX -> Vector MX -> IO () +casadi__Function__call__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> IO () +function_call__0 x = casadi__Function__call__0 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__1" c_casadi__Function__call__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () +casadi__Function__call__1 + :: Function -> Vector MX -> Vector MX -> Bool -> IO () +casadi__Function__call__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> IO () +function_call__1 x = casadi__Function__call__1 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__2" c_casadi__Function__call__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO () +casadi__Function__call__2 + :: Function -> Vector MX -> Vector MX -> Bool -> Bool -> IO () +casadi__Function__call__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Bool -> Bool -> IO () +function_call__2 x = casadi__Function__call__2 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__3" c_casadi__Function__call__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () +casadi__Function__call__3 + :: Function -> Vector SX -> Vector SX -> IO () +casadi__Function__call__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> IO () +function_call__3 x = casadi__Function__call__3 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__4" c_casadi__Function__call__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO () +casadi__Function__call__4 + :: Function -> Vector SX -> Vector SX -> Bool -> IO () +casadi__Function__call__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> IO () +function_call__4 x = casadi__Function__call__4 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__5" c_casadi__Function__call__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO () +casadi__Function__call__5 + :: Function -> Vector SX -> Vector SX -> Bool -> Bool -> IO () +casadi__Function__call__5 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__5 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Bool -> Bool -> IO () +function_call__5 x = casadi__Function__call__5 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__6" c_casadi__Function__call__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO () +casadi__Function__call__6 + :: Function -> Vector DMatrix -> Vector DMatrix -> IO () +casadi__Function__call__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> IO () +function_call__6 x = casadi__Function__call__6 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__7" c_casadi__Function__call__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO () +casadi__Function__call__7 + :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () +casadi__Function__call__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () +function_call__7 x = casadi__Function__call__7 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__call__8" c_casadi__Function__call__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO () +casadi__Function__call__8 + :: Function -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO () +casadi__Function__call__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__call__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_call__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Bool -> Bool -> IO () +function_call__8 x = casadi__Function__call__8 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__0" c_casadi__Function__callDerivative__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () +casadi__Function__callDerivative__0 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO () +casadi__Function__callDerivative__0 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__0 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> IO () +function_callDerivative__0 x = casadi__Function__callDerivative__0 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__1" c_casadi__Function__callDerivative__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () +casadi__Function__callDerivative__1 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () +casadi__Function__callDerivative__1 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__1 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () +function_callDerivative__1 x = casadi__Function__callDerivative__1 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__2" c_casadi__Function__callDerivative__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () +casadi__Function__callDerivative__2 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () +casadi__Function__callDerivative__2 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__2 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () +function_callDerivative__2 x = casadi__Function__callDerivative__2 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__3" c_casadi__Function__callDerivative__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () +casadi__Function__callDerivative__3 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO () +casadi__Function__callDerivative__3 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__3 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> IO () +function_callDerivative__3 x = casadi__Function__callDerivative__3 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__4" c_casadi__Function__callDerivative__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () +casadi__Function__callDerivative__4 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () +casadi__Function__callDerivative__4 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__4 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () +function_callDerivative__4 x = casadi__Function__callDerivative__4 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__5" c_casadi__Function__callDerivative__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () +casadi__Function__callDerivative__5 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () +casadi__Function__callDerivative__5 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () +function_callDerivative__5 x = casadi__Function__callDerivative__5 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__6" c_casadi__Function__callDerivative__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () +casadi__Function__callDerivative__6 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () +casadi__Function__callDerivative__6 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__6 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () +function_callDerivative__6 x = casadi__Function__callDerivative__6 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__7" c_casadi__Function__callDerivative__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () +casadi__Function__callDerivative__7 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () +casadi__Function__callDerivative__7 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__7 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () +function_callDerivative__7 x = casadi__Function__callDerivative__7 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callDerivative__8" c_casadi__Function__callDerivative__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () +casadi__Function__callDerivative__8 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () +casadi__Function__callDerivative__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callDerivative__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callDerivative__8 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () +function_callDerivative__8 x = casadi__Function__callDerivative__8 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__0" c_casadi__Function__callForward__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () +casadi__Function__callForward__0 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () +casadi__Function__callForward__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () +function_callForward__0 x = casadi__Function__callForward__0 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__1" c_casadi__Function__callForward__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () +casadi__Function__callForward__1 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () +casadi__Function__callForward__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () +function_callForward__1 x = casadi__Function__callForward__1 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__2" c_casadi__Function__callForward__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () +casadi__Function__callForward__2 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () +casadi__Function__callForward__2 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () +function_callForward__2 x = casadi__Function__callForward__2 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__3" c_casadi__Function__callForward__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () +casadi__Function__callForward__3 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () +casadi__Function__callForward__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () +function_callForward__3 x = casadi__Function__callForward__3 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__4" c_casadi__Function__callForward__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () +casadi__Function__callForward__4 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () +casadi__Function__callForward__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () +function_callForward__4 x = casadi__Function__callForward__4 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__5" c_casadi__Function__callForward__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () +casadi__Function__callForward__5 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () +casadi__Function__callForward__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () +function_callForward__5 x = casadi__Function__callForward__5 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__6" c_casadi__Function__callForward__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () +casadi__Function__callForward__6 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () +casadi__Function__callForward__6 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__6 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () +function_callForward__6 x = casadi__Function__callForward__6 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__7" c_casadi__Function__callForward__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () +casadi__Function__callForward__7 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () +casadi__Function__callForward__7 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__7 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () +function_callForward__7 x = casadi__Function__callForward__7 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callForward__8" c_casadi__Function__callForward__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () +casadi__Function__callForward__8 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () +casadi__Function__callForward__8 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callForward__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callForward__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () +function_callForward__8 x = casadi__Function__callForward__8 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__0" c_casadi__Function__callReverse__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO () +casadi__Function__callReverse__0 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () +casadi__Function__callReverse__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__0 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> IO () +function_callReverse__0 x = casadi__Function__callReverse__0 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__1" c_casadi__Function__callReverse__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> IO () +casadi__Function__callReverse__1 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () +casadi__Function__callReverse__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__1 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> IO () +function_callReverse__1 x = casadi__Function__callReverse__1 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__2" c_casadi__Function__callReverse__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> CInt -> CInt -> IO () +casadi__Function__callReverse__2 + :: Function -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () +casadi__Function__callReverse__2 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__2 :: FunctionClass a => a -> Vector DMatrix -> Vector DMatrix -> Vector (Vector DMatrix) -> Vector (Vector DMatrix) -> Bool -> Bool -> IO () +function_callReverse__2 x = casadi__Function__callReverse__2 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__3" c_casadi__Function__callReverse__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO () +casadi__Function__callReverse__3 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () +casadi__Function__callReverse__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__3 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> IO () +function_callReverse__3 x = casadi__Function__callReverse__3 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__4" c_casadi__Function__callReverse__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> IO () +casadi__Function__callReverse__4 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () +casadi__Function__callReverse__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__4 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> IO () +function_callReverse__4 x = casadi__Function__callReverse__4 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__5" c_casadi__Function__callReverse__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> CInt -> CInt -> IO () +casadi__Function__callReverse__5 + :: Function -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () +casadi__Function__callReverse__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__5 :: FunctionClass a => a -> Vector SX -> Vector SX -> Vector (Vector SX) -> Vector (Vector SX) -> Bool -> Bool -> IO () +function_callReverse__5 x = casadi__Function__callReverse__5 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__6" c_casadi__Function__callReverse__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO () +casadi__Function__callReverse__6 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () +casadi__Function__callReverse__6 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__6 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__6 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> IO () +function_callReverse__6 x = casadi__Function__callReverse__6 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__7" c_casadi__Function__callReverse__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> IO () +casadi__Function__callReverse__7 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () +casadi__Function__callReverse__7 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__7 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__7 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> IO () +function_callReverse__7 x = casadi__Function__callReverse__7 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__callReverse__8" c_casadi__Function__callReverse__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> CInt -> CInt -> IO () +casadi__Function__callReverse__8 + :: Function -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () +casadi__Function__callReverse__8 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__callReverse__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_callReverse__8 :: FunctionClass a => a -> Vector MX -> Vector MX -> Vector (Vector MX) -> Vector (Vector MX) -> Bool -> Bool -> IO () +function_callReverse__8 x = casadi__Function__callReverse__8 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__checkInputs" c_casadi__Function__checkInputs + :: Ptr (Ptr StdString) -> Ptr Function' -> IO () +casadi__Function__checkInputs + :: Function -> IO () +casadi__Function__checkInputs x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__checkInputs errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_checkInputs :: FunctionClass a => a -> IO () +function_checkInputs x = casadi__Function__checkInputs (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__defaultInput" c_casadi__Function__defaultInput + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CDouble +casadi__Function__defaultInput + :: Function -> Int -> IO Double +casadi__Function__defaultInput x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__defaultInput errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_defaultInput :: FunctionClass a => a -> Int -> IO Double +function_defaultInput x = casadi__Function__defaultInput (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__derForward" c_casadi__Function__derForward + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') +casadi__Function__derForward + :: Function -> Int -> IO Function +casadi__Function__derForward x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__derForward errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_derForward :: FunctionClass a => a -> Int -> IO Function +function_derForward x = casadi__Function__derForward (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__derReverse" c_casadi__Function__derReverse + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') +casadi__Function__derReverse + :: Function -> Int -> IO Function +casadi__Function__derReverse x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__derReverse errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_derReverse :: FunctionClass a => a -> Int -> IO Function +function_derReverse x = casadi__Function__derReverse (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__derivative" c_casadi__Function__derivative + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__derivative + :: Function -> Int -> Int -> IO Function +casadi__Function__derivative x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__derivative errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_derivative :: FunctionClass a => a -> Int -> Int -> IO Function +function_derivative x = casadi__Function__derivative (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__evaluate" c_casadi__Function__evaluate + :: Ptr (Ptr StdString) -> Ptr Function' -> IO () +casadi__Function__evaluate + :: Function -> IO () +casadi__Function__evaluate x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__evaluate errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_evaluate :: FunctionClass a => a -> IO () +function_evaluate x = casadi__Function__evaluate (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__fullJacobian" c_casadi__Function__fullJacobian + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') +casadi__Function__fullJacobian + :: Function -> IO Function +casadi__Function__fullJacobian x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__fullJacobian errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_fullJacobian :: FunctionClass a => a -> IO Function +function_fullJacobian x = casadi__Function__fullJacobian (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__generate__0" c_casadi__Function__generate__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO () +casadi__Function__generate__0 + :: Function -> IO () +casadi__Function__generate__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__generate__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_generate__0 :: FunctionClass a => a -> IO () +function_generate__0 x = casadi__Function__generate__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__generate__1" c_casadi__Function__generate__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO () +casadi__Function__generate__1 + :: Function -> M.Map String GenericType -> IO () +casadi__Function__generate__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__generate__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_generate__1 :: FunctionClass a => a -> M.Map String GenericType -> IO () +function_generate__1 x = casadi__Function__generate__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__generate__2" c_casadi__Function__generate__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () +casadi__Function__generate__2 + :: Function -> String -> IO () +casadi__Function__generate__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__generate__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_generate__2 :: FunctionClass a => a -> String -> IO () +function_generate__2 x = casadi__Function__generate__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__generate__3" c_casadi__Function__generate__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO () +casadi__Function__generate__3 + :: Function -> String -> M.Map String GenericType -> IO () +casadi__Function__generate__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__generate__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_generate__3 :: FunctionClass a => a -> String -> M.Map String GenericType -> IO () +function_generate__3 x = casadi__Function__generate__3 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__getSanitizedName" c_casadi__Function__getSanitizedName + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr StdString) +casadi__Function__getSanitizedName + :: Function -> IO String +casadi__Function__getSanitizedName x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__getSanitizedName errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_getSanitizedName :: FunctionClass a => a -> IO String +function_getSanitizedName x = casadi__Function__getSanitizedName (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__getStat" c_casadi__Function__getStat + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr GenericType') +casadi__Function__getStat + :: Function -> String -> IO GenericType +casadi__Function__getStat x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__getStat errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_getStat :: FunctionClass a => a -> String -> IO GenericType +function_getStat x = casadi__Function__getStat (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__getStats" c_casadi__Function__getStats + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdMap StdString (Ptr GenericType'))) +casadi__Function__getStats + :: Function -> IO (M.Map String GenericType) +casadi__Function__getStats x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__getStats errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_getStats :: FunctionClass a => a -> IO (M.Map String GenericType) +function_getStats x = casadi__Function__getStats (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__gradient__0" c_casadi__Function__gradient__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') +casadi__Function__gradient__0 + :: Function -> String -> String -> IO Function +casadi__Function__gradient__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__gradient__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_gradient__0 :: FunctionClass a => a -> String -> String -> IO Function +function_gradient__0 x = casadi__Function__gradient__0 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__gradient__1" c_casadi__Function__gradient__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') +casadi__Function__gradient__1 + :: Function -> Int -> String -> IO Function +casadi__Function__gradient__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__gradient__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_gradient__1 :: FunctionClass a => a -> Int -> String -> IO Function +function_gradient__1 x = casadi__Function__gradient__1 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__gradient__2" c_casadi__Function__gradient__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') +casadi__Function__gradient__2 + :: Function -> String -> IO Function +casadi__Function__gradient__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__gradient__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_gradient__2 :: FunctionClass a => a -> String -> IO Function +function_gradient__2 x = casadi__Function__gradient__2 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__gradient__3" c_casadi__Function__gradient__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') +casadi__Function__gradient__3 + :: Function -> String -> Int -> IO Function +casadi__Function__gradient__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__gradient__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_gradient__3 :: FunctionClass a => a -> String -> Int -> IO Function +function_gradient__3 x = casadi__Function__gradient__3 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__gradient__4" c_casadi__Function__gradient__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') +casadi__Function__gradient__4 + :: Function -> IO Function +casadi__Function__gradient__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__gradient__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_gradient__4 :: FunctionClass a => a -> IO Function +function_gradient__4 x = casadi__Function__gradient__4 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__gradient__5" c_casadi__Function__gradient__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') +casadi__Function__gradient__5 + :: Function -> Int -> IO Function +casadi__Function__gradient__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__gradient__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_gradient__5 :: FunctionClass a => a -> Int -> IO Function +function_gradient__5 x = casadi__Function__gradient__5 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__gradient__6" c_casadi__Function__gradient__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__gradient__6 + :: Function -> Int -> Int -> IO Function +casadi__Function__gradient__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__gradient__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_gradient__6 :: FunctionClass a => a -> Int -> Int -> IO Function +function_gradient__6 x = casadi__Function__gradient__6 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__hessian__0" c_casadi__Function__hessian__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') +casadi__Function__hessian__0 + :: Function -> String -> String -> IO Function +casadi__Function__hessian__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__hessian__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_hessian__0 :: FunctionClass a => a -> String -> String -> IO Function +function_hessian__0 x = casadi__Function__hessian__0 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__hessian__1" c_casadi__Function__hessian__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') +casadi__Function__hessian__1 + :: Function -> Int -> String -> IO Function +casadi__Function__hessian__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__hessian__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_hessian__1 :: FunctionClass a => a -> Int -> String -> IO Function +function_hessian__1 x = casadi__Function__hessian__1 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__hessian__2" c_casadi__Function__hessian__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') +casadi__Function__hessian__2 + :: Function -> String -> IO Function +casadi__Function__hessian__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__hessian__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_hessian__2 :: FunctionClass a => a -> String -> IO Function +function_hessian__2 x = casadi__Function__hessian__2 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__hessian__3" c_casadi__Function__hessian__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') +casadi__Function__hessian__3 + :: Function -> String -> Int -> IO Function +casadi__Function__hessian__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__hessian__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_hessian__3 :: FunctionClass a => a -> String -> Int -> IO Function +function_hessian__3 x = casadi__Function__hessian__3 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__hessian__4" c_casadi__Function__hessian__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') +casadi__Function__hessian__4 + :: Function -> IO Function +casadi__Function__hessian__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__hessian__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_hessian__4 :: FunctionClass a => a -> IO Function +function_hessian__4 x = casadi__Function__hessian__4 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__hessian__5" c_casadi__Function__hessian__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') +casadi__Function__hessian__5 + :: Function -> Int -> IO Function +casadi__Function__hessian__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__hessian__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_hessian__5 :: FunctionClass a => a -> Int -> IO Function +function_hessian__5 x = casadi__Function__hessian__5 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__hessian__6" c_casadi__Function__hessian__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__hessian__6 + :: Function -> Int -> Int -> IO Function +casadi__Function__hessian__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__hessian__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_hessian__6 :: FunctionClass a => a -> Int -> Int -> IO Function +function_hessian__6 x = casadi__Function__hessian__6 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__inputDescription" c_casadi__Function__inputDescription + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) +casadi__Function__inputDescription + :: Function -> Int -> IO String +casadi__Function__inputDescription x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__inputDescription errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_inputDescription :: FunctionClass a => a -> Int -> IO String +function_inputDescription x = casadi__Function__inputDescription (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__inputIndex" c_casadi__Function__inputIndex + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt +casadi__Function__inputIndex + :: Function -> String -> IO Int +casadi__Function__inputIndex x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__inputIndex errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_inputIndex :: FunctionClass a => a -> String -> IO Int +function_inputIndex x = casadi__Function__inputIndex (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__inputName" c_casadi__Function__inputName + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) +casadi__Function__inputName + :: Function -> Int -> IO String +casadi__Function__inputName x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__inputName errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_inputName :: FunctionClass a => a -> Int -> IO String +function_inputName x = casadi__Function__inputName (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__inputScheme" c_casadi__Function__inputScheme + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString))) +casadi__Function__inputScheme + :: Function -> IO (Vector String) +casadi__Function__inputScheme x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__inputScheme errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_inputScheme :: FunctionClass a => a -> IO (Vector String) +function_inputScheme x = casadi__Function__inputScheme (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__inputSparsity__0" c_casadi__Function__inputSparsity__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity') +casadi__Function__inputSparsity__0 + :: Function -> String -> IO Sparsity +casadi__Function__inputSparsity__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__inputSparsity__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_inputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity +function_inputSparsity__0 x = casadi__Function__inputSparsity__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__inputSparsity__1" c_casadi__Function__inputSparsity__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity') +casadi__Function__inputSparsity__1 + :: Function -> IO Sparsity +casadi__Function__inputSparsity__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__inputSparsity__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_inputSparsity__1 :: FunctionClass a => a -> IO Sparsity +function_inputSparsity__1 x = casadi__Function__inputSparsity__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__inputSparsity__2" c_casadi__Function__inputSparsity__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity') +casadi__Function__inputSparsity__2 + :: Function -> Int -> IO Sparsity +casadi__Function__inputSparsity__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__inputSparsity__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_inputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity +function_inputSparsity__2 x = casadi__Function__inputSparsity__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__0" c_casadi__Function__jacSparsity__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__0 + :: Function -> String -> String -> IO Sparsity +casadi__Function__jacSparsity__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__0 :: FunctionClass a => a -> String -> String -> IO Sparsity +function_jacSparsity__0 x = casadi__Function__jacSparsity__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__1" c_casadi__Function__jacSparsity__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__1 + :: Function -> String -> String -> Bool -> IO Sparsity +casadi__Function__jacSparsity__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Sparsity +function_jacSparsity__1 x = casadi__Function__jacSparsity__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__2" c_casadi__Function__jacSparsity__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__2 + :: Function -> String -> String -> Bool -> Bool -> IO Sparsity +casadi__Function__jacSparsity__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Sparsity +function_jacSparsity__2 x = casadi__Function__jacSparsity__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__3" c_casadi__Function__jacSparsity__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__3 + :: Function -> Int -> String -> IO Sparsity +casadi__Function__jacSparsity__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__3 :: FunctionClass a => a -> Int -> String -> IO Sparsity +function_jacSparsity__3 x = casadi__Function__jacSparsity__3 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__4" c_casadi__Function__jacSparsity__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__4 + :: Function -> Int -> String -> Bool -> IO Sparsity +casadi__Function__jacSparsity__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Sparsity +function_jacSparsity__4 x = casadi__Function__jacSparsity__4 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__5" c_casadi__Function__jacSparsity__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__5 + :: Function -> Int -> String -> Bool -> Bool -> IO Sparsity +casadi__Function__jacSparsity__5 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__5 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Sparsity +function_jacSparsity__5 x = casadi__Function__jacSparsity__5 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__6" c_casadi__Function__jacSparsity__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__6 + :: Function -> String -> IO Sparsity +casadi__Function__jacSparsity__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__6 :: FunctionClass a => a -> String -> IO Sparsity +function_jacSparsity__6 x = casadi__Function__jacSparsity__6 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__7" c_casadi__Function__jacSparsity__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__7 + :: Function -> String -> Int -> IO Sparsity +casadi__Function__jacSparsity__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__7 :: FunctionClass a => a -> String -> Int -> IO Sparsity +function_jacSparsity__7 x = casadi__Function__jacSparsity__7 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__8" c_casadi__Function__jacSparsity__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__8 + :: Function -> String -> Int -> Bool -> IO Sparsity +casadi__Function__jacSparsity__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Sparsity +function_jacSparsity__8 x = casadi__Function__jacSparsity__8 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__9" c_casadi__Function__jacSparsity__9 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__9 + :: Function -> String -> Int -> Bool -> Bool -> IO Sparsity +casadi__Function__jacSparsity__9 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__9 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Sparsity +function_jacSparsity__9 x = casadi__Function__jacSparsity__9 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__10" c_casadi__Function__jacSparsity__10 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__10 + :: Function -> IO Sparsity +casadi__Function__jacSparsity__10 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__10 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__10 :: FunctionClass a => a -> IO Sparsity +function_jacSparsity__10 x = casadi__Function__jacSparsity__10 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__11" c_casadi__Function__jacSparsity__11 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__11 + :: Function -> Int -> IO Sparsity +casadi__Function__jacSparsity__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__11 :: FunctionClass a => a -> Int -> IO Sparsity +function_jacSparsity__11 x = casadi__Function__jacSparsity__11 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__12" c_casadi__Function__jacSparsity__12 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__12 + :: Function -> Int -> Int -> IO Sparsity +casadi__Function__jacSparsity__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__12 :: FunctionClass a => a -> Int -> Int -> IO Sparsity +function_jacSparsity__12 x = casadi__Function__jacSparsity__12 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__13" c_casadi__Function__jacSparsity__13 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__13 + :: Function -> Int -> Int -> Bool -> IO Sparsity +casadi__Function__jacSparsity__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Sparsity +function_jacSparsity__13 x = casadi__Function__jacSparsity__13 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__jacSparsity__14" c_casadi__Function__jacSparsity__14 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Function__jacSparsity__14 + :: Function -> Int -> Int -> Bool -> Bool -> IO Sparsity +casadi__Function__jacSparsity__14 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacSparsity__14 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacSparsity__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Sparsity +function_jacSparsity__14 x = casadi__Function__jacSparsity__14 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__0" c_casadi__Function__jacobian__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> IO (Ptr Function') +casadi__Function__jacobian__0 + :: Function -> String -> String -> IO Function +casadi__Function__jacobian__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__0 :: FunctionClass a => a -> String -> String -> IO Function +function_jacobian__0 x = casadi__Function__jacobian__0 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__1" c_casadi__Function__jacobian__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__1 + :: Function -> String -> String -> Bool -> IO Function +casadi__Function__jacobian__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__1 :: FunctionClass a => a -> String -> String -> Bool -> IO Function +function_jacobian__1 x = casadi__Function__jacobian__1 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__2" c_casadi__Function__jacobian__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__2 + :: Function -> String -> String -> Bool -> Bool -> IO Function +casadi__Function__jacobian__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__2 :: FunctionClass a => a -> String -> String -> Bool -> Bool -> IO Function +function_jacobian__2 x = casadi__Function__jacobian__2 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__3" c_casadi__Function__jacobian__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> IO (Ptr Function') +casadi__Function__jacobian__3 + :: Function -> Int -> String -> IO Function +casadi__Function__jacobian__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__3 :: FunctionClass a => a -> Int -> String -> IO Function +function_jacobian__3 x = casadi__Function__jacobian__3 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__4" c_casadi__Function__jacobian__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__4 + :: Function -> Int -> String -> Bool -> IO Function +casadi__Function__jacobian__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__4 :: FunctionClass a => a -> Int -> String -> Bool -> IO Function +function_jacobian__4 x = casadi__Function__jacobian__4 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__5" c_casadi__Function__jacobian__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__5 + :: Function -> Int -> String -> Bool -> Bool -> IO Function +casadi__Function__jacobian__5 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__5 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__5 :: FunctionClass a => a -> Int -> String -> Bool -> Bool -> IO Function +function_jacobian__5 x = casadi__Function__jacobian__5 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__6" c_casadi__Function__jacobian__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function') +casadi__Function__jacobian__6 + :: Function -> String -> IO Function +casadi__Function__jacobian__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__6 :: FunctionClass a => a -> String -> IO Function +function_jacobian__6 x = casadi__Function__jacobian__6 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__7" c_casadi__Function__jacobian__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__7 + :: Function -> String -> Int -> IO Function +casadi__Function__jacobian__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__7 :: FunctionClass a => a -> String -> Int -> IO Function +function_jacobian__7 x = casadi__Function__jacobian__7 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__8" c_casadi__Function__jacobian__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__8 + :: Function -> String -> Int -> Bool -> IO Function +casadi__Function__jacobian__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__8 :: FunctionClass a => a -> String -> Int -> Bool -> IO Function +function_jacobian__8 x = casadi__Function__jacobian__8 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__9" c_casadi__Function__jacobian__9 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__9 + :: Function -> String -> Int -> Bool -> Bool -> IO Function +casadi__Function__jacobian__9 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__9 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__9 :: FunctionClass a => a -> String -> Int -> Bool -> Bool -> IO Function +function_jacobian__9 x = casadi__Function__jacobian__9 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__10" c_casadi__Function__jacobian__10 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function') +casadi__Function__jacobian__10 + :: Function -> IO Function +casadi__Function__jacobian__10 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__10 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__10 :: FunctionClass a => a -> IO Function +function_jacobian__10 x = casadi__Function__jacobian__10 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__11" c_casadi__Function__jacobian__11 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__11 + :: Function -> Int -> IO Function +casadi__Function__jacobian__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__11 :: FunctionClass a => a -> Int -> IO Function +function_jacobian__11 x = casadi__Function__jacobian__11 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__12" c_casadi__Function__jacobian__12 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__12 + :: Function -> Int -> Int -> IO Function +casadi__Function__jacobian__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__12 :: FunctionClass a => a -> Int -> Int -> IO Function +function_jacobian__12 x = casadi__Function__jacobian__12 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__13" c_casadi__Function__jacobian__13 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__13 + :: Function -> Int -> Int -> Bool -> IO Function +casadi__Function__jacobian__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__13 :: FunctionClass a => a -> Int -> Int -> Bool -> IO Function +function_jacobian__13 x = casadi__Function__jacobian__13 (castFunction x) + + +-- direct wrapper +foreign import ccall safe "casadi__Function__jacobian__14" c_casadi__Function__jacobian__14 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Function') +casadi__Function__jacobian__14 + :: Function -> Int -> Int -> Bool -> Bool -> IO Function +casadi__Function__jacobian__14 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__jacobian__14 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_jacobian__14 :: FunctionClass a => a -> Int -> Int -> Bool -> Bool -> IO Function +function_jacobian__14 x = casadi__Function__jacobian__14 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__map__0" c_casadi__Function__map__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') +casadi__Function__map__0 + :: Function -> String -> Int -> IO Function +casadi__Function__map__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__map__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_map__0 :: FunctionClass a => a -> String -> Int -> IO Function +function_map__0 x = casadi__Function__map__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__map__1" c_casadi__Function__map__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function') +casadi__Function__map__1 + :: Function -> String -> Int -> M.Map String GenericType -> IO Function +casadi__Function__map__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__map__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_map__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function +function_map__1 x = casadi__Function__map__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__map__2" c_casadi__Function__map__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__map__2 + :: Function -> Vector MX -> IO (Vector MX) +casadi__Function__map__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__map__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_map__2 :: FunctionClass a => a -> Vector MX -> IO (Vector MX) +function_map__2 x = casadi__Function__map__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__map__3" c_casadi__Function__map__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__map__3 + :: Function -> Vector MX -> String -> IO (Vector MX) +casadi__Function__map__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__map__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_map__3 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX) +function_map__3 x = casadi__Function__map__3 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__map__4" c_casadi__Function__map__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi__Function__map__4 + :: Function -> Vector (Vector MX) -> IO (Vector (Vector MX)) +casadi__Function__map__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__map__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_map__4 :: FunctionClass a => a -> Vector (Vector MX) -> IO (Vector (Vector MX)) +function_map__4 x = casadi__Function__map__4 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__map__5" c_casadi__Function__map__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi__Function__map__5 + :: Function -> Vector (Vector MX) -> String -> IO (Vector (Vector MX)) +casadi__Function__map__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__map__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_map__5 :: FunctionClass a => a -> Vector (Vector MX) -> String -> IO (Vector (Vector MX)) +function_map__5 x = casadi__Function__map__5 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__mapaccum__0" c_casadi__Function__mapaccum__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO (Ptr Function') +casadi__Function__mapaccum__0 + :: Function -> String -> Int -> IO Function +casadi__Function__mapaccum__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__mapaccum__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_mapaccum__0 :: FunctionClass a => a -> String -> Int -> IO Function +function_mapaccum__0 x = casadi__Function__mapaccum__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__mapaccum__1" c_casadi__Function__mapaccum__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Function') +casadi__Function__mapaccum__1 + :: Function -> String -> Int -> M.Map String GenericType -> IO Function +casadi__Function__mapaccum__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__mapaccum__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_mapaccum__1 :: FunctionClass a => a -> String -> Int -> M.Map String GenericType -> IO Function +function_mapaccum__1 x = casadi__Function__mapaccum__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__mapsum__0" c_casadi__Function__mapsum__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__mapsum__0 + :: Function -> Vector MX -> IO (Vector MX) +casadi__Function__mapsum__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__mapsum__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_mapsum__0 :: FunctionClass a => a -> Vector MX -> IO (Vector MX) +function_mapsum__0 x = casadi__Function__mapsum__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__mapsum__1" c_casadi__Function__mapsum__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__mapsum__1 + :: Function -> Vector MX -> String -> IO (Vector MX) +casadi__Function__mapsum__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__mapsum__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_mapsum__1 :: FunctionClass a => a -> Vector MX -> String -> IO (Vector MX) +function_mapsum__1 x = casadi__Function__mapsum__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__nIn" c_casadi__Function__nIn + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt +casadi__Function__nIn + :: Function -> IO Int +casadi__Function__nIn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__nIn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_nIn :: FunctionClass a => a -> IO Int +function_nIn x = casadi__Function__nIn (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__nOut" c_casadi__Function__nOut + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt +casadi__Function__nOut + :: Function -> IO Int +casadi__Function__nOut x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__nOut errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_nOut :: FunctionClass a => a -> IO Int +function_nOut x = casadi__Function__nOut (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__nnzIn" c_casadi__Function__nnzIn + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt +casadi__Function__nnzIn + :: Function -> IO Int +casadi__Function__nnzIn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__nnzIn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_nnzIn :: FunctionClass a => a -> IO Int +function_nnzIn x = casadi__Function__nnzIn (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__nnzOut" c_casadi__Function__nnzOut + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt +casadi__Function__nnzOut + :: Function -> IO Int +casadi__Function__nnzOut x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__nnzOut errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_nnzOut :: FunctionClass a => a -> IO Int +function_nnzOut x = casadi__Function__nnzOut (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__numelIn" c_casadi__Function__numelIn + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt +casadi__Function__numelIn + :: Function -> IO Int +casadi__Function__numelIn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__numelIn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_numelIn :: FunctionClass a => a -> IO Int +function_numelIn x = casadi__Function__numelIn (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__numelOut" c_casadi__Function__numelOut + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CInt +casadi__Function__numelOut + :: Function -> IO Int +casadi__Function__numelOut x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__numelOut errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_numelOut :: FunctionClass a => a -> IO Int +function_numelOut x = casadi__Function__numelOut (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__0" c_casadi__Function__operator_call__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr (StdMap StdString (Ptr MX'))) +casadi__Function__operator_call__0 + :: Function -> M.Map String MX -> IO (M.Map String MX) +casadi__Function__operator_call__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__0 :: FunctionClass a => a -> M.Map String MX -> IO (M.Map String MX) +function_operator_call__0 x = casadi__Function__operator_call__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__1" c_casadi__Function__operator_call__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> CInt -> IO (Ptr (StdMap StdString (Ptr MX'))) +casadi__Function__operator_call__1 + :: Function -> M.Map String MX -> Bool -> IO (M.Map String MX) +casadi__Function__operator_call__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__1 :: FunctionClass a => a -> M.Map String MX -> Bool -> IO (M.Map String MX) +function_operator_call__1 x = casadi__Function__operator_call__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__2" c_casadi__Function__operator_call__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr MX'))) +casadi__Function__operator_call__2 + :: Function -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX) +casadi__Function__operator_call__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__2 :: FunctionClass a => a -> M.Map String MX -> Bool -> Bool -> IO (M.Map String MX) +function_operator_call__2 x = casadi__Function__operator_call__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__3" c_casadi__Function__operator_call__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr (StdMap StdString (Ptr SX'))) +casadi__Function__operator_call__3 + :: Function -> M.Map String SX -> IO (M.Map String SX) +casadi__Function__operator_call__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__3 :: FunctionClass a => a -> M.Map String SX -> IO (M.Map String SX) +function_operator_call__3 x = casadi__Function__operator_call__3 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__4" c_casadi__Function__operator_call__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> CInt -> IO (Ptr (StdMap StdString (Ptr SX'))) +casadi__Function__operator_call__4 + :: Function -> M.Map String SX -> Bool -> IO (M.Map String SX) +casadi__Function__operator_call__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__4 :: FunctionClass a => a -> M.Map String SX -> Bool -> IO (M.Map String SX) +function_operator_call__4 x = casadi__Function__operator_call__4 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__5" c_casadi__Function__operator_call__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr SX'))) +casadi__Function__operator_call__5 + :: Function -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX) +casadi__Function__operator_call__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__5 :: FunctionClass a => a -> M.Map String SX -> Bool -> Bool -> IO (M.Map String SX) +function_operator_call__5 x = casadi__Function__operator_call__5 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__6" c_casadi__Function__operator_call__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> IO (Ptr (StdMap StdString (Ptr DMatrix'))) +casadi__Function__operator_call__6 + :: Function -> M.Map String DMatrix -> IO (M.Map String DMatrix) +casadi__Function__operator_call__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__6 :: FunctionClass a => a -> M.Map String DMatrix -> IO (M.Map String DMatrix) +function_operator_call__6 x = casadi__Function__operator_call__6 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__7" c_casadi__Function__operator_call__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> CInt -> IO (Ptr (StdMap StdString (Ptr DMatrix'))) +casadi__Function__operator_call__7 + :: Function -> M.Map String DMatrix -> Bool -> IO (M.Map String DMatrix) +casadi__Function__operator_call__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__7 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> IO (M.Map String DMatrix) +function_operator_call__7 x = casadi__Function__operator_call__7 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__8" c_casadi__Function__operator_call__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdMap StdString (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdMap StdString (Ptr DMatrix'))) +casadi__Function__operator_call__8 + :: Function -> M.Map String DMatrix -> Bool -> Bool -> IO (M.Map String DMatrix) +casadi__Function__operator_call__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__8 :: FunctionClass a => a -> M.Map String DMatrix -> Bool -> Bool -> IO (M.Map String DMatrix) +function_operator_call__8 x = casadi__Function__operator_call__8 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__9" c_casadi__Function__operator_call__9 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__operator_call__9 + :: Function -> Vector MX -> IO (Vector MX) +casadi__Function__operator_call__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__9 :: FunctionClass a => a -> Vector MX -> IO (Vector MX) +function_operator_call__9 x = casadi__Function__operator_call__9 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__10" c_casadi__Function__operator_call__10 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__operator_call__10 + :: Function -> Vector MX -> Bool -> IO (Vector MX) +casadi__Function__operator_call__10 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__10 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__10 :: FunctionClass a => a -> Vector MX -> Bool -> IO (Vector MX) +function_operator_call__10 x = casadi__Function__operator_call__10 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__11" c_casadi__Function__operator_call__11 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr MX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__operator_call__11 + :: Function -> Vector MX -> Bool -> Bool -> IO (Vector MX) +casadi__Function__operator_call__11 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__11 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__11 :: FunctionClass a => a -> Vector MX -> Bool -> Bool -> IO (Vector MX) +function_operator_call__11 x = casadi__Function__operator_call__11 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__12" c_casadi__Function__operator_call__12 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) +casadi__Function__operator_call__12 + :: Function -> Vector SX -> IO (Vector SX) +casadi__Function__operator_call__12 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__12 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__12 :: FunctionClass a => a -> Vector SX -> IO (Vector SX) +function_operator_call__12 x = casadi__Function__operator_call__12 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__13" c_casadi__Function__operator_call__13 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi__Function__operator_call__13 + :: Function -> Vector SX -> Bool -> IO (Vector SX) +casadi__Function__operator_call__13 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__13 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__13 :: FunctionClass a => a -> Vector SX -> Bool -> IO (Vector SX) +function_operator_call__13 x = casadi__Function__operator_call__13 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__14" c_casadi__Function__operator_call__14 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr SX')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi__Function__operator_call__14 + :: Function -> Vector SX -> Bool -> Bool -> IO (Vector SX) +casadi__Function__operator_call__14 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__14 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__14 :: FunctionClass a => a -> Vector SX -> Bool -> Bool -> IO (Vector SX) +function_operator_call__14 x = casadi__Function__operator_call__14 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__15" c_casadi__Function__operator_call__15 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi__Function__operator_call__15 + :: Function -> Vector DMatrix -> IO (Vector DMatrix) +casadi__Function__operator_call__15 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__15 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__15 :: FunctionClass a => a -> Vector DMatrix -> IO (Vector DMatrix) +function_operator_call__15 x = casadi__Function__operator_call__15 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__16" c_casadi__Function__operator_call__16 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi__Function__operator_call__16 + :: Function -> Vector DMatrix -> Bool -> IO (Vector DMatrix) +casadi__Function__operator_call__16 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__16 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__16 :: FunctionClass a => a -> Vector DMatrix -> Bool -> IO (Vector DMatrix) +function_operator_call__16 x = casadi__Function__operator_call__16 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__operator_call__17" c_casadi__Function__operator_call__17 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi__Function__operator_call__17 + :: Function -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix) +casadi__Function__operator_call__17 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__operator_call__17 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_operator_call__17 :: FunctionClass a => a -> Vector DMatrix -> Bool -> Bool -> IO (Vector DMatrix) +function_operator_call__17 x = casadi__Function__operator_call__17 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__outputDescription" c_casadi__Function__outputDescription + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) +casadi__Function__outputDescription + :: Function -> Int -> IO String +casadi__Function__outputDescription x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__outputDescription errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_outputDescription :: FunctionClass a => a -> Int -> IO String +function_outputDescription x = casadi__Function__outputDescription (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__outputIndex" c_casadi__Function__outputIndex + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO CInt +casadi__Function__outputIndex + :: Function -> String -> IO Int +casadi__Function__outputIndex x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__outputIndex errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_outputIndex :: FunctionClass a => a -> String -> IO Int +function_outputIndex x = casadi__Function__outputIndex (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__outputName" c_casadi__Function__outputName + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) +casadi__Function__outputName + :: Function -> Int -> IO String +casadi__Function__outputName x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__outputName errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_outputName :: FunctionClass a => a -> Int -> IO String +function_outputName x = casadi__Function__outputName (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__outputScheme" c_casadi__Function__outputScheme + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr StdString))) +casadi__Function__outputScheme + :: Function -> IO (Vector String) +casadi__Function__outputScheme x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__outputScheme errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_outputScheme :: FunctionClass a => a -> IO (Vector String) +function_outputScheme x = casadi__Function__outputScheme (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__outputSparsity__0" c_casadi__Function__outputSparsity__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Sparsity') +casadi__Function__outputSparsity__0 + :: Function -> String -> IO Sparsity +casadi__Function__outputSparsity__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__outputSparsity__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_outputSparsity__0 :: FunctionClass a => a -> String -> IO Sparsity +function_outputSparsity__0 x = casadi__Function__outputSparsity__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__outputSparsity__1" c_casadi__Function__outputSparsity__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Sparsity') +casadi__Function__outputSparsity__1 + :: Function -> IO Sparsity +casadi__Function__outputSparsity__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__outputSparsity__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_outputSparsity__1 :: FunctionClass a => a -> IO Sparsity +function_outputSparsity__1 x = casadi__Function__outputSparsity__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__outputSparsity__2" c_casadi__Function__outputSparsity__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr Sparsity') +casadi__Function__outputSparsity__2 + :: Function -> Int -> IO Sparsity +casadi__Function__outputSparsity__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__outputSparsity__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_outputSparsity__2 :: FunctionClass a => a -> Int -> IO Sparsity +function_outputSparsity__2 x = casadi__Function__outputSparsity__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__printDimensions" c_casadi__Function__printDimensions + :: Ptr (Ptr StdString) -> Ptr Function' -> IO () +casadi__Function__printDimensions + :: Function -> IO () +casadi__Function__printDimensions x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__printDimensions errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_printDimensions :: FunctionClass a => a -> IO () +function_printDimensions x = casadi__Function__printDimensions (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__removeMonitor" c_casadi__Function__removeMonitor + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO () +casadi__Function__removeMonitor + :: Function -> String -> IO () +casadi__Function__removeMonitor x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__removeMonitor errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_removeMonitor :: FunctionClass a => a -> String -> IO () +function_removeMonitor x = casadi__Function__removeMonitor (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__sanitizeName" c_casadi__Function__sanitizeName + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString) +casadi__Function__sanitizeName + :: String -> IO String +casadi__Function__sanitizeName x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__sanitizeName errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_sanitizeName :: String -> IO String +function_sanitizeName = casadi__Function__sanitizeName + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setDerForward" c_casadi__Function__setDerForward + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () +casadi__Function__setDerForward + :: Function -> Function -> Int -> IO () +casadi__Function__setDerForward x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setDerForward errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setDerForward :: FunctionClass a => a -> Function -> Int -> IO () +function_setDerForward x = casadi__Function__setDerForward (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setDerReverse" c_casadi__Function__setDerReverse + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () +casadi__Function__setDerReverse + :: Function -> Function -> Int -> IO () +casadi__Function__setDerReverse x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setDerReverse errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setDerReverse :: FunctionClass a => a -> Function -> Int -> IO () +function_setDerReverse x = casadi__Function__setDerReverse (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setFullJacobian" c_casadi__Function__setFullJacobian + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO () +casadi__Function__setFullJacobian + :: Function -> Function -> IO () +casadi__Function__setFullJacobian x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setFullJacobian errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setFullJacobian :: FunctionClass a => a -> Function -> IO () +function_setFullJacobian x = casadi__Function__setFullJacobian (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__0" c_casadi__Function__setJacSparsity__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> IO () +casadi__Function__setJacSparsity__0 + :: Function -> Sparsity -> String -> String -> IO () +casadi__Function__setJacSparsity__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__0 :: FunctionClass a => a -> Sparsity -> String -> String -> IO () +function_setJacSparsity__0 x = casadi__Function__setJacSparsity__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__1" c_casadi__Function__setJacSparsity__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> Ptr StdString -> CInt -> IO () +casadi__Function__setJacSparsity__1 + :: Function -> Sparsity -> String -> String -> Bool -> IO () +casadi__Function__setJacSparsity__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__1 :: FunctionClass a => a -> Sparsity -> String -> String -> Bool -> IO () +function_setJacSparsity__1 x = casadi__Function__setJacSparsity__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__2" c_casadi__Function__setJacSparsity__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> IO () +casadi__Function__setJacSparsity__2 + :: Function -> Sparsity -> Int -> String -> IO () +casadi__Function__setJacSparsity__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__2 :: FunctionClass a => a -> Sparsity -> Int -> String -> IO () +function_setJacSparsity__2 x = casadi__Function__setJacSparsity__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__3" c_casadi__Function__setJacSparsity__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> Ptr StdString -> CInt -> IO () +casadi__Function__setJacSparsity__3 + :: Function -> Sparsity -> Int -> String -> Bool -> IO () +casadi__Function__setJacSparsity__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__3 :: FunctionClass a => a -> Sparsity -> Int -> String -> Bool -> IO () +function_setJacSparsity__3 x = casadi__Function__setJacSparsity__3 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__4" c_casadi__Function__setJacSparsity__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> IO () +casadi__Function__setJacSparsity__4 + :: Function -> Sparsity -> String -> Int -> IO () +casadi__Function__setJacSparsity__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__4 :: FunctionClass a => a -> Sparsity -> String -> Int -> IO () +function_setJacSparsity__4 x = casadi__Function__setJacSparsity__4 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__5" c_casadi__Function__setJacSparsity__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> Ptr StdString -> CInt -> CInt -> IO () +casadi__Function__setJacSparsity__5 + :: Function -> Sparsity -> String -> Int -> Bool -> IO () +casadi__Function__setJacSparsity__5 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__5 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__5 :: FunctionClass a => a -> Sparsity -> String -> Int -> Bool -> IO () +function_setJacSparsity__5 x = casadi__Function__setJacSparsity__5 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__6" c_casadi__Function__setJacSparsity__6 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> IO () +casadi__Function__setJacSparsity__6 + :: Function -> Sparsity -> Int -> Int -> IO () +casadi__Function__setJacSparsity__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__6 :: FunctionClass a => a -> Sparsity -> Int -> Int -> IO () +function_setJacSparsity__6 x = casadi__Function__setJacSparsity__6 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacSparsity__7" c_casadi__Function__setJacSparsity__7 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Sparsity' -> CInt -> CInt -> CInt -> IO () +casadi__Function__setJacSparsity__7 + :: Function -> Sparsity -> Int -> Int -> Bool -> IO () +casadi__Function__setJacSparsity__7 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacSparsity__7 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacSparsity__7 :: FunctionClass a => a -> Sparsity -> Int -> Int -> Bool -> IO () +function_setJacSparsity__7 x = casadi__Function__setJacSparsity__7 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacobian__0" c_casadi__Function__setJacobian__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO () +casadi__Function__setJacobian__0 + :: Function -> Function -> IO () +casadi__Function__setJacobian__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacobian__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacobian__0 :: FunctionClass a => a -> Function -> IO () +function_setJacobian__0 x = casadi__Function__setJacobian__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacobian__1" c_casadi__Function__setJacobian__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> IO () +casadi__Function__setJacobian__1 + :: Function -> Function -> Int -> IO () +casadi__Function__setJacobian__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacobian__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacobian__1 :: FunctionClass a => a -> Function -> Int -> IO () +function_setJacobian__1 x = casadi__Function__setJacobian__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacobian__2" c_casadi__Function__setJacobian__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> IO () +casadi__Function__setJacobian__2 + :: Function -> Function -> Int -> Int -> IO () +casadi__Function__setJacobian__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacobian__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacobian__2 :: FunctionClass a => a -> Function -> Int -> Int -> IO () +function_setJacobian__2 x = casadi__Function__setJacobian__2 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__setJacobian__3" c_casadi__Function__setJacobian__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> CInt -> CInt -> CInt -> IO () +casadi__Function__setJacobian__3 + :: Function -> Function -> Int -> Int -> Bool -> IO () +casadi__Function__setJacobian__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__setJacobian__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_setJacobian__3 :: FunctionClass a => a -> Function -> Int -> Int -> Bool -> IO () +function_setJacobian__3 x = casadi__Function__setJacobian__3 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__spCanEvaluate" c_casadi__Function__spCanEvaluate + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO CInt +casadi__Function__spCanEvaluate + :: Function -> Bool -> IO Bool +casadi__Function__spCanEvaluate x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__spCanEvaluate errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_spCanEvaluate :: FunctionClass a => a -> Bool -> IO Bool +function_spCanEvaluate x = casadi__Function__spCanEvaluate (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__spEvaluate" c_casadi__Function__spEvaluate + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO () +casadi__Function__spEvaluate + :: Function -> Bool -> IO () +casadi__Function__spEvaluate x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__spEvaluate errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_spEvaluate :: FunctionClass a => a -> Bool -> IO () +function_spEvaluate x = casadi__Function__spEvaluate (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__spInit" c_casadi__Function__spInit + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO () +casadi__Function__spInit + :: Function -> Bool -> IO () +casadi__Function__spInit x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__spInit errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_spInit :: FunctionClass a => a -> Bool -> IO () +function_spInit x = casadi__Function__spInit (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__symbolicInput__0" c_casadi__Function__symbolicInput__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__symbolicInput__0 + :: Function -> IO (Vector MX) +casadi__Function__symbolicInput__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__symbolicInput__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_symbolicInput__0 :: FunctionClass a => a -> IO (Vector MX) +function_symbolicInput__0 x = casadi__Function__symbolicInput__0 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__symbolicInput__1" c_casadi__Function__symbolicInput__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__symbolicInput__1 + :: Function -> Bool -> IO (Vector MX) +casadi__Function__symbolicInput__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__symbolicInput__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_symbolicInput__1 :: FunctionClass a => a -> Bool -> IO (Vector MX) +function_symbolicInput__1 x = casadi__Function__symbolicInput__1 (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__symbolicInputSX" c_casadi__Function__symbolicInputSX + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr SX'))) +casadi__Function__symbolicInputSX + :: Function -> IO (Vector SX) +casadi__Function__symbolicInputSX x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__symbolicInputSX errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_symbolicInputSX :: FunctionClass a => a -> IO (Vector SX) +function_symbolicInputSX x = casadi__Function__symbolicInputSX (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__symbolicOutput" c_casadi__Function__symbolicOutput + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr (StdVec (Ptr MX'))) +casadi__Function__symbolicOutput + :: Function -> IO (Vector MX) +casadi__Function__symbolicOutput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__symbolicOutput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_symbolicOutput :: FunctionClass a => a -> IO (Vector MX) +function_symbolicOutput x = casadi__Function__symbolicOutput (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__sz_arg" c_casadi__Function__sz_arg + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize +casadi__Function__sz_arg + :: Function -> IO CSize +casadi__Function__sz_arg x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__sz_arg errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_sz_arg :: FunctionClass a => a -> IO CSize +function_sz_arg x = casadi__Function__sz_arg (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__sz_iw" c_casadi__Function__sz_iw + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize +casadi__Function__sz_iw + :: Function -> IO CSize +casadi__Function__sz_iw x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__sz_iw errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_sz_iw :: FunctionClass a => a -> IO CSize +function_sz_iw x = casadi__Function__sz_iw (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__sz_res" c_casadi__Function__sz_res + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize +casadi__Function__sz_res + :: Function -> IO CSize +casadi__Function__sz_res x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__sz_res errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_sz_res :: FunctionClass a => a -> IO CSize +function_sz_res x = casadi__Function__sz_res (castFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Function__sz_w" c_casadi__Function__sz_w + :: Ptr (Ptr StdString) -> Ptr Function' -> IO CSize +casadi__Function__sz_w + :: Function -> IO CSize +casadi__Function__sz_w x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Function__sz_w errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +function_sz_w :: FunctionClass a => a -> IO CSize +function_sz_w x = casadi__Function__sz_w (castFunction x) -- direct wrapper diff --git a/Casadi/Core/Classes/Functor.hs b/Casadi/Core/Classes/Functor.hs --- a/Casadi/Core/Classes/Functor.hs +++ b/Casadi/Core/Classes/Functor.hs @@ -15,6 +15,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -22,9 +23,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data diff --git a/Casadi/Core/Classes/GenericExpressionCommon.hs b/Casadi/Core/Classes/GenericExpressionCommon.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/GenericExpressionCommon.hs @@ -0,0 +1,31 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.GenericExpressionCommon + ( + GenericExpressionCommon, + GenericExpressionCommonClass(..), + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums diff --git a/Casadi/Core/Classes/GenericMatrixCommon.hs b/Casadi/Core/Classes/GenericMatrixCommon.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/GenericMatrixCommon.hs @@ -0,0 +1,31 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.GenericMatrixCommon + ( + GenericMatrixCommon, + GenericMatrixCommonClass(..), + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums diff --git a/Casadi/Core/Classes/GenericType.hs b/Casadi/Core/Classes/GenericType.hs --- a/Casadi/Core/Classes/GenericType.hs +++ b/Casadi/Core/Classes/GenericType.hs @@ -30,27 +30,29 @@ genericType_get_description, genericType_get_type_description, genericType_isBool, - genericType_isDictionary, + genericType_isCallback, + genericType_isDerivativeGenerator, + genericType_isDict, genericType_isDouble, genericType_isDoubleVector, - genericType_isEmptyVector, genericType_isFunction, genericType_isInt, genericType_isIntVector, genericType_isIntVectorVector, - genericType_isSharedObject, genericType_isString, genericType_isStringVector, + genericType_isVoidPointer, + genericType_isemptyVector, genericType_operator_equals, genericType_operator_nequals, genericType_toBool, + genericType_toDict, genericType_toDouble, genericType_toDoubleVector, genericType_toFunction, genericType_toInt, genericType_toIntVector, genericType_toIntVectorVector, - genericType_toSharedObject, genericType_toString, genericType_toStringVector, genericType_toVoidPointer, @@ -60,6 +62,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -67,18 +70,17 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__0" c_casadi__GenericType__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr Callback' -> IO (Ptr GenericType') + :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr GenericType') casadi__GenericType__CONSTRUCTOR__0 - :: Callback -> IO GenericType + :: M.Map String GenericType -> IO GenericType casadi__GenericType__CONSTRUCTOR__0 x0 = withMarshal x0 $ \x0' -> do @@ -90,15 +92,15 @@ -- classy wrapper -genericType__0 :: Callback -> IO GenericType +genericType__0 :: M.Map String GenericType -> IO GenericType genericType__0 = casadi__GenericType__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__1" c_casadi__GenericType__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator' -> IO (Ptr GenericType') + :: Ptr (Ptr StdString) -> Ptr Callback' -> IO (Ptr GenericType') casadi__GenericType__CONSTRUCTOR__1 - :: DerivativeGenerator -> IO GenericType + :: Callback -> IO GenericType casadi__GenericType__CONSTRUCTOR__1 x0 = withMarshal x0 $ \x0' -> do @@ -110,15 +112,15 @@ -- classy wrapper -genericType__1 :: DerivativeGenerator -> IO GenericType +genericType__1 :: Callback -> IO GenericType genericType__1 = casadi__GenericType__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__2" c_casadi__GenericType__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO (Ptr GenericType') + :: Ptr (Ptr StdString) -> Ptr DerivativeGenerator' -> IO (Ptr GenericType') casadi__GenericType__CONSTRUCTOR__2 - :: SharedObject -> IO GenericType + :: DerivativeGenerator -> IO GenericType casadi__GenericType__CONSTRUCTOR__2 x0 = withMarshal x0 $ \x0' -> do @@ -130,7 +132,7 @@ -- classy wrapper -genericType__2 :: SharedObject -> IO GenericType +genericType__2 :: DerivativeGenerator -> IO GenericType genericType__2 = casadi__GenericType__CONSTRUCTOR__2 @@ -379,7 +381,7 @@ foreign import ccall unsafe "casadi__GenericType__can_cast_to__1" c_casadi__GenericType__can_cast_to__1 :: Ptr (Ptr StdString) -> Ptr GenericType' -> CInt -> IO CInt casadi__GenericType__can_cast_to__1 - :: GenericType -> Opt_type -> IO Bool + :: GenericType -> TypeID -> IO Bool casadi__GenericType__can_cast_to__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> @@ -392,7 +394,7 @@ -- classy wrapper -genericType_can_cast_to__1 :: GenericTypeClass a => a -> Opt_type -> IO Bool +genericType_can_cast_to__1 :: GenericTypeClass a => a -> TypeID -> IO Bool genericType_can_cast_to__1 x = casadi__GenericType__can_cast_to__1 (castGenericType x) @@ -400,7 +402,7 @@ foreign import ccall unsafe "casadi__GenericType__from_type" c_casadi__GenericType__from_type :: Ptr (Ptr StdString) -> CInt -> IO (Ptr GenericType') casadi__GenericType__from_type - :: Opt_type -> IO GenericType + :: TypeID -> IO GenericType casadi__GenericType__from_type x0 = withMarshal x0 $ \x0' -> do @@ -412,7 +414,7 @@ -- classy wrapper -genericType_from_type :: Opt_type -> IO GenericType +genericType_from_type :: TypeID -> IO GenericType genericType_from_type = casadi__GenericType__from_type @@ -420,7 +422,7 @@ foreign import ccall unsafe "casadi__GenericType__getType" c_casadi__GenericType__getType :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt casadi__GenericType__getType - :: GenericType -> IO Opt_type + :: GenericType -> IO TypeID casadi__GenericType__getType x0 = withMarshal x0 $ \x0' -> do @@ -432,7 +434,7 @@ -- classy wrapper -genericType_getType :: GenericTypeClass a => a -> IO Opt_type +genericType_getType :: GenericTypeClass a => a -> IO TypeID genericType_getType x = casadi__GenericType__getType (castGenericType x) @@ -460,7 +462,7 @@ foreign import ccall unsafe "casadi__GenericType__get_type_description" c_casadi__GenericType__get_type_description :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString) casadi__GenericType__get_type_description - :: Opt_type -> IO String + :: TypeID -> IO String casadi__GenericType__get_type_description x0 = withMarshal x0 $ \x0' -> do @@ -472,7 +474,7 @@ -- classy wrapper -genericType_get_type_description :: Opt_type -> IO String +genericType_get_type_description :: TypeID -> IO String genericType_get_type_description = casadi__GenericType__get_type_description @@ -497,86 +499,106 @@ -- direct wrapper -foreign import ccall unsafe "casadi__GenericType__isDictionary" c_casadi__GenericType__isDictionary +foreign import ccall unsafe "casadi__GenericType__isCallback" c_casadi__GenericType__isCallback :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt -casadi__GenericType__isDictionary +casadi__GenericType__isCallback :: GenericType -> IO Bool -casadi__GenericType__isDictionary x0 = +casadi__GenericType__isCallback x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__isDictionary errStrPtrP x0' + ret <- c_casadi__GenericType__isCallback errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -genericType_isDictionary :: GenericTypeClass a => a -> IO Bool -genericType_isDictionary x = casadi__GenericType__isDictionary (castGenericType x) +genericType_isCallback :: GenericTypeClass a => a -> IO Bool +genericType_isCallback x = casadi__GenericType__isCallback (castGenericType x) -- direct wrapper -foreign import ccall unsafe "casadi__GenericType__isDouble" c_casadi__GenericType__isDouble +foreign import ccall unsafe "casadi__GenericType__isDerivativeGenerator" c_casadi__GenericType__isDerivativeGenerator :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt -casadi__GenericType__isDouble +casadi__GenericType__isDerivativeGenerator :: GenericType -> IO Bool -casadi__GenericType__isDouble x0 = +casadi__GenericType__isDerivativeGenerator x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__isDouble errStrPtrP x0' + ret <- c_casadi__GenericType__isDerivativeGenerator errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -genericType_isDouble :: GenericTypeClass a => a -> IO Bool -genericType_isDouble x = casadi__GenericType__isDouble (castGenericType x) +genericType_isDerivativeGenerator :: GenericTypeClass a => a -> IO Bool +genericType_isDerivativeGenerator x = casadi__GenericType__isDerivativeGenerator (castGenericType x) -- direct wrapper -foreign import ccall unsafe "casadi__GenericType__isDoubleVector" c_casadi__GenericType__isDoubleVector +foreign import ccall unsafe "casadi__GenericType__isDict" c_casadi__GenericType__isDict :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt -casadi__GenericType__isDoubleVector +casadi__GenericType__isDict :: GenericType -> IO Bool -casadi__GenericType__isDoubleVector x0 = +casadi__GenericType__isDict x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__isDoubleVector errStrPtrP x0' + ret <- c_casadi__GenericType__isDict errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -genericType_isDoubleVector :: GenericTypeClass a => a -> IO Bool -genericType_isDoubleVector x = casadi__GenericType__isDoubleVector (castGenericType x) +genericType_isDict :: GenericTypeClass a => a -> IO Bool +genericType_isDict x = casadi__GenericType__isDict (castGenericType x) -- direct wrapper -foreign import ccall unsafe "casadi__GenericType__isEmptyVector" c_casadi__GenericType__isEmptyVector +foreign import ccall unsafe "casadi__GenericType__isDouble" c_casadi__GenericType__isDouble :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt -casadi__GenericType__isEmptyVector +casadi__GenericType__isDouble :: GenericType -> IO Bool -casadi__GenericType__isEmptyVector x0 = +casadi__GenericType__isDouble x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__isEmptyVector errStrPtrP x0' + ret <- c_casadi__GenericType__isDouble errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -genericType_isEmptyVector :: GenericTypeClass a => a -> IO Bool -genericType_isEmptyVector x = casadi__GenericType__isEmptyVector (castGenericType x) +genericType_isDouble :: GenericTypeClass a => a -> IO Bool +genericType_isDouble x = casadi__GenericType__isDouble (castGenericType x) -- direct wrapper +foreign import ccall unsafe "casadi__GenericType__isDoubleVector" c_casadi__GenericType__isDoubleVector + :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt +casadi__GenericType__isDoubleVector + :: GenericType -> IO Bool +casadi__GenericType__isDoubleVector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__GenericType__isDoubleVector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +genericType_isDoubleVector :: GenericTypeClass a => a -> IO Bool +genericType_isDoubleVector x = casadi__GenericType__isDoubleVector (castGenericType x) + + +-- direct wrapper foreign import ccall unsafe "casadi__GenericType__isFunction" c_casadi__GenericType__isFunction :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt casadi__GenericType__isFunction @@ -657,66 +679,86 @@ -- direct wrapper -foreign import ccall unsafe "casadi__GenericType__isSharedObject" c_casadi__GenericType__isSharedObject +foreign import ccall unsafe "casadi__GenericType__isString" c_casadi__GenericType__isString :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt -casadi__GenericType__isSharedObject +casadi__GenericType__isString :: GenericType -> IO Bool -casadi__GenericType__isSharedObject x0 = +casadi__GenericType__isString x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__isSharedObject errStrPtrP x0' + ret <- c_casadi__GenericType__isString errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -genericType_isSharedObject :: GenericTypeClass a => a -> IO Bool -genericType_isSharedObject x = casadi__GenericType__isSharedObject (castGenericType x) +genericType_isString :: GenericTypeClass a => a -> IO Bool +genericType_isString x = casadi__GenericType__isString (castGenericType x) -- direct wrapper -foreign import ccall unsafe "casadi__GenericType__isString" c_casadi__GenericType__isString +foreign import ccall unsafe "casadi__GenericType__isStringVector" c_casadi__GenericType__isStringVector :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt -casadi__GenericType__isString +casadi__GenericType__isStringVector :: GenericType -> IO Bool -casadi__GenericType__isString x0 = +casadi__GenericType__isStringVector x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__isString errStrPtrP x0' + ret <- c_casadi__GenericType__isStringVector errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -genericType_isString :: GenericTypeClass a => a -> IO Bool -genericType_isString x = casadi__GenericType__isString (castGenericType x) +genericType_isStringVector :: GenericTypeClass a => a -> IO Bool +genericType_isStringVector x = casadi__GenericType__isStringVector (castGenericType x) -- direct wrapper -foreign import ccall unsafe "casadi__GenericType__isStringVector" c_casadi__GenericType__isStringVector +foreign import ccall unsafe "casadi__GenericType__isVoidPointer" c_casadi__GenericType__isVoidPointer :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt -casadi__GenericType__isStringVector +casadi__GenericType__isVoidPointer :: GenericType -> IO Bool -casadi__GenericType__isStringVector x0 = +casadi__GenericType__isVoidPointer x0 = withMarshal x0 $ \x0' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__isStringVector errStrPtrP x0' + ret <- c_casadi__GenericType__isVoidPointer errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -genericType_isStringVector :: GenericTypeClass a => a -> IO Bool -genericType_isStringVector x = casadi__GenericType__isStringVector (castGenericType x) +genericType_isVoidPointer :: GenericTypeClass a => a -> IO Bool +genericType_isVoidPointer x = casadi__GenericType__isVoidPointer (castGenericType x) -- direct wrapper +foreign import ccall unsafe "casadi__GenericType__isemptyVector" c_casadi__GenericType__isemptyVector + :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CInt +casadi__GenericType__isemptyVector + :: GenericType -> IO Bool +casadi__GenericType__isemptyVector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__GenericType__isemptyVector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +genericType_isemptyVector :: GenericTypeClass a => a -> IO Bool +genericType_isemptyVector x = casadi__GenericType__isemptyVector (castGenericType x) + + +-- direct wrapper foreign import ccall unsafe "casadi__GenericType__operator_nequals" c_casadi__GenericType__operator_nequals :: Ptr (Ptr StdString) -> Ptr GenericType' -> Ptr GenericType' -> IO CInt casadi__GenericType__operator_nequals @@ -779,6 +821,26 @@ -- direct wrapper +foreign import ccall unsafe "casadi__GenericType__toDict" c_casadi__GenericType__toDict + :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr (StdMap StdString (Ptr GenericType'))) +casadi__GenericType__toDict + :: GenericType -> IO (M.Map String GenericType) +casadi__GenericType__toDict x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__GenericType__toDict errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +genericType_toDict :: GenericTypeClass a => a -> IO (M.Map String GenericType) +genericType_toDict x = casadi__GenericType__toDict (castGenericType x) + + +-- direct wrapper foreign import ccall unsafe "casadi__GenericType__toDouble" c_casadi__GenericType__toDouble :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO CDouble casadi__GenericType__toDouble @@ -896,26 +958,6 @@ -- classy wrapper genericType_toIntVectorVector :: GenericTypeClass a => a -> IO (Vector (Vector Int)) genericType_toIntVectorVector x = casadi__GenericType__toIntVectorVector (castGenericType x) - - --- direct wrapper -foreign import ccall unsafe "casadi__GenericType__toSharedObject" c_casadi__GenericType__toSharedObject - :: Ptr (Ptr StdString) -> Ptr GenericType' -> IO (Ptr SharedObject') -casadi__GenericType__toSharedObject - :: GenericType -> IO SharedObject -casadi__GenericType__toSharedObject x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__GenericType__toSharedObject errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -genericType_toSharedObject :: GenericTypeClass a => a -> IO SharedObject -genericType_toSharedObject x = casadi__GenericType__toSharedObject (castGenericType x) -- direct wrapper diff --git a/Casadi/Core/Classes/HomotopyNlpSolver.hs b/Casadi/Core/Classes/HomotopyNlpSolver.hs --- a/Casadi/Core/Classes/HomotopyNlpSolver.hs +++ b/Casadi/Core/Classes/HomotopyNlpSolver.hs @@ -19,6 +19,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -26,9 +27,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data diff --git a/Casadi/Core/Classes/IMatrix.hs b/Casadi/Core/Classes/IMatrix.hs --- a/Casadi/Core/Classes/IMatrix.hs +++ b/Casadi/Core/Classes/IMatrix.hs @@ -17,7182 +17,3877 @@ imatrix__4, imatrix__5, imatrix__6, - imatrix___constpow__, - imatrix___copysign__, - imatrix___mldivide__, - imatrix___mrdivide__, - imatrix___nonzero__, - imatrix___truediv____0, - imatrix___truediv____1, - imatrix_append, - imatrix_appendColumns, - imatrix_binary, - imatrix_className, - imatrix_clear, - imatrix_colind, - imatrix_dimString, - imatrix_enlarge__0, - imatrix_enlarge__1, - imatrix_erase__0, - imatrix_erase__1, - imatrix_erase__2, - imatrix_erase__3, - imatrix_eye, - imatrix_find__0, - imatrix_find__1, - imatrix_getColind, - imatrix_getDep__0, - imatrix_getDep__1, - imatrix_getDescription, - imatrix_getElementHash, - imatrix_getEqualityCheckingDepth, - imatrix_getIntValue, - imatrix_getMaxNumCallsInPrint, - imatrix_getNZ__0, - imatrix_getNZ__1, - imatrix_getNZ__2, - imatrix_getName, - imatrix_getNdeps, - imatrix_getRepresentation, - imatrix_getRow, - imatrix_getSparsity, - imatrix_getSym, - imatrix_getValue__0, - imatrix_getValue__1, - imatrix_get__0, - imatrix_get__1, - imatrix_get__2, - imatrix_get__3, - imatrix_get__4, - imatrix_get__5, - imatrix_get__6, - imatrix_get__7, - imatrix_hasNZ, - imatrix_hasNonStructuralZeros, - imatrix_inf__0, - imatrix_inf__1, - imatrix_inf__2, - imatrix_inf__3, - imatrix_isCommutative, - imatrix_isConstant, - imatrix_isDense, - imatrix_isEmpty__0, - imatrix_isEmpty__1, - imatrix_isIdentity, - imatrix_isInteger, - imatrix_isLeaf, - imatrix_isMinusOne, - imatrix_isOne, - imatrix_isRegular, - imatrix_isRowVector, - imatrix_isScalar__0, - imatrix_isScalar__1, - imatrix_isSlice__0, - imatrix_isSlice__1, - imatrix_isSmooth, - imatrix_isSquare, - imatrix_isSymbolic, - imatrix_isSymbolicSparse, - imatrix_isTril, - imatrix_isTriu, - imatrix_isVector__0, - imatrix_isVector__1, - imatrix_isZero, - imatrix_makeSparse__0, - imatrix_makeSparse__1, - imatrix_matrix_matrix, - imatrix_matrix_scalar, - imatrix_nan__0, - imatrix_nan__1, - imatrix_nan__2, - imatrix_nan__3, - imatrix_nnz, - imatrix_nonzeros, - imatrix_nonzeros_int, - imatrix_numel__0, - imatrix_numel__1, - imatrix_ones__0, - imatrix_ones__1, - imatrix_ones__2, - imatrix_ones__3, - imatrix_operator_minus, - imatrix_operator_plus, - imatrix_printDense, - imatrix_printScalar, - imatrix_printSparse, - imatrix_printVector, - imatrix_printme, - imatrix_remove, - imatrix_reserve__0, - imatrix_reserve__1, - imatrix_resize, - imatrix_row, - imatrix_sanityCheck__0, - imatrix_sanityCheck__1, - imatrix_scalar_matrix, - imatrix_setEqualityCheckingDepth__0, - imatrix_setEqualityCheckingDepth__1, - imatrix_setMaxNumCallsInPrint__0, - imatrix_setMaxNumCallsInPrint__1, - imatrix_setNZ__0, - imatrix_setNZ__1, - imatrix_setNZ__2, - imatrix_setNZ__3, - imatrix_setPrecision, - imatrix_setScientific, - imatrix_setSparse__0, - imatrix_setSparse__1, - imatrix_setSym, - imatrix_setValue__0, - imatrix_setValue__1, - imatrix_setWidth, - imatrix_setZero, - imatrix_set__0, - imatrix_set__1, - imatrix_set__10, - imatrix_set__2, - imatrix_set__3, - imatrix_set__4, - imatrix_set__5, - imatrix_set__6, - imatrix_set__7, - imatrix_set__8, - imatrix_set__9, - imatrix_size1, - imatrix_size2, - imatrix_sizeD, - imatrix_sizeL, - imatrix_sizeU, - imatrix_size__0, - imatrix_size__1, - imatrix_sparse__0, - imatrix_sparse__1, - imatrix_sparse__2, - imatrix_sparse__3, - imatrix_sparsity, - imatrix_sparsityRef, - imatrix_sym__0, - imatrix_sym__1, - imatrix_sym__2, - imatrix_sym__3, - imatrix_sym__4, - imatrix_sym__5, - imatrix_sym__6, - imatrix_sym__7, - imatrix_toSlice__0, - imatrix_toSlice__1, - imatrix_triplet__0, - imatrix_triplet__1, - imatrix_unary, - imatrix_zeros__0, - imatrix_zeros__1, - imatrix_zeros__2, - imatrix_zeros__3, - imatrix_zz_abs, - imatrix_zz_acos, - imatrix_zz_acosh, - imatrix_zz_adj, - imatrix_zz_all, - imatrix_zz_and, - imatrix_zz_any, - imatrix_zz_asin, - imatrix_zz_asinh, - imatrix_zz_atan, - imatrix_zz_atan2, - imatrix_zz_atanh, - imatrix_zz_blockcat, - imatrix_zz_blocksplit, - imatrix_zz_ceil, - imatrix_zz_cofactor, - imatrix_zz_cos, - imatrix_zz_cosh, - imatrix_zz_countNodes, - imatrix_zz_cross__0, - imatrix_zz_cross__1, - imatrix_zz_densify, - imatrix_zz_dependsOn, - imatrix_zz_det, - imatrix_zz_diag, - imatrix_zz_diagcat, - imatrix_zz_diagsplit, - imatrix_zz_eig_symbolic, - imatrix_zz_eq, - imatrix_zz_erf, - imatrix_zz_erfinv, - imatrix_zz_exp, - imatrix_zz_expand, - imatrix_zz_extractShared__0, - imatrix_zz_extractShared__1, - imatrix_zz_extractShared__2, - imatrix_zz_floor, - imatrix_zz_gauss_quadrature__0, - imatrix_zz_gauss_quadrature__1, - imatrix_zz_gauss_quadrature__2, - imatrix_zz_ge, - imatrix_zz_getMinor, - imatrix_zz_getOperatorRepresentation, - imatrix_zz_getSymbols__0, - imatrix_zz_getSymbols__1, - imatrix_zz_gradient, - imatrix_zz_gt, - imatrix_zz_heaviside, - imatrix_zz_hessian__0, - imatrix_zz_hessian__1, - imatrix_zz_horzcat, - imatrix_zz_horzsplit, - imatrix_zz_if_else, - imatrix_zz_if_else_zero, - imatrix_zz_inner_prod, - imatrix_zz_inv, - imatrix_zz_isEqual__0, - imatrix_zz_isEqual__1, - imatrix_zz_jacobian, - imatrix_zz_jacobianTimesVector__0, - imatrix_zz_jacobianTimesVector__1, - imatrix_zz_kron, - imatrix_zz_le, - imatrix_zz_linspace, - imatrix_zz_log, - imatrix_zz_log10, - imatrix_zz_lt, - imatrix_zz_max, - imatrix_zz_min, - imatrix_zz_minus, - imatrix_zz_mod, - imatrix_zz_mpower, - imatrix_zz_mtaylor__0, - imatrix_zz_mtaylor__1, - imatrix_zz_mtaylor__2, - imatrix_zz_mtimes__0, - imatrix_zz_mtimes__1, - imatrix_zz_ne, - imatrix_zz_norm_0_mul, - imatrix_zz_norm_1, - imatrix_zz_norm_2, - imatrix_zz_norm_F, - imatrix_zz_norm_inf, - imatrix_zz_norm_inf_mul, - imatrix_zz_not, - imatrix_zz_nullspace, - imatrix_zz_or, - imatrix_zz_outer_prod, - imatrix_zz_pinv, - imatrix_zz_plus, - imatrix_zz_poly_coeff, - imatrix_zz_poly_roots, - imatrix_zz_polyval, - imatrix_zz_power, - imatrix_zz_printCompact, - imatrix_zz_project, - imatrix_zz_pw_const, - imatrix_zz_pw_lin, - imatrix_zz_qr, - imatrix_zz_quad_form__0, - imatrix_zz_quad_form__1, - imatrix_zz_quad_form__2, - imatrix_zz_quad_form__3, - imatrix_zz_ramp, - imatrix_zz_rdivide, - imatrix_zz_rectangle, - imatrix_zz_repmat__0, - imatrix_zz_repmat__1, - imatrix_zz_reshape__0, - imatrix_zz_reshape__1, - imatrix_zz_sign, - imatrix_zz_simplify, - imatrix_zz_sin, - imatrix_zz_sinh, - imatrix_zz_solve, - imatrix_zz_sparsify__0, - imatrix_zz_sparsify__1, - imatrix_zz_sprank, - imatrix_zz_spy, - imatrix_zz_sqrt, - imatrix_zz_substituteInPlace__0, - imatrix_zz_substituteInPlace__1, - imatrix_zz_substitute__0, - imatrix_zz_substitute__1, - imatrix_zz_sumAll, - imatrix_zz_sumCols, - imatrix_zz_sumRows, - imatrix_zz_sum_square, - imatrix_zz_tan, - imatrix_zz_tangent, - imatrix_zz_tanh, - imatrix_zz_taylor__0, - imatrix_zz_taylor__1, - imatrix_zz_taylor__2, - imatrix_zz_times, - imatrix_zz_trace, - imatrix_zz_triangle, - imatrix_zz_tril2symm, - imatrix_zz_tril__0, - imatrix_zz_tril__1, - imatrix_zz_triu2symm, - imatrix_zz_triu__0, - imatrix_zz_triu__1, - imatrix_zz_unite, - imatrix_zz_vec, - imatrix_zz_vecNZ, - imatrix_zz_vecNZcat, - imatrix_zz_veccat, - imatrix_zz_vertcat, - imatrix_zz_vertsplit, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__0" c_casadi__IMatrix__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr IMatrix') -casadi__IMatrix__CONSTRUCTOR__0 - :: Vector (Vector Double) -> IO IMatrix -casadi__IMatrix__CONSTRUCTOR__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__CONSTRUCTOR__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix__0 :: Vector (Vector Double) -> IO IMatrix -imatrix__0 = casadi__IMatrix__CONSTRUCTOR__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__1" c_casadi__IMatrix__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr IMatrix') -casadi__IMatrix__CONSTRUCTOR__1 - :: Double -> IO IMatrix -casadi__IMatrix__CONSTRUCTOR__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__CONSTRUCTOR__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix__1 :: Double -> IO IMatrix -imatrix__1 = casadi__IMatrix__CONSTRUCTOR__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__2" c_casadi__IMatrix__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__CONSTRUCTOR__2 - :: Sparsity -> IMatrix -> IO IMatrix -casadi__IMatrix__CONSTRUCTOR__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__CONSTRUCTOR__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix__2 :: Sparsity -> IMatrix -> IO IMatrix -imatrix__2 = casadi__IMatrix__CONSTRUCTOR__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__3" c_casadi__IMatrix__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__CONSTRUCTOR__3 - :: Sparsity -> IO IMatrix -casadi__IMatrix__CONSTRUCTOR__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__CONSTRUCTOR__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix__3 :: Sparsity -> IO IMatrix -imatrix__3 = casadi__IMatrix__CONSTRUCTOR__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__4" c_casadi__IMatrix__CONSTRUCTOR__4 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__CONSTRUCTOR__4 - :: Int -> Int -> IO IMatrix -casadi__IMatrix__CONSTRUCTOR__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__CONSTRUCTOR__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix__4 :: Int -> Int -> IO IMatrix -imatrix__4 = casadi__IMatrix__CONSTRUCTOR__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__5" c_casadi__IMatrix__CONSTRUCTOR__5 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__CONSTRUCTOR__5 - :: IMatrix -> IO IMatrix -casadi__IMatrix__CONSTRUCTOR__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__CONSTRUCTOR__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix__5 :: IMatrix -> IO IMatrix -imatrix__5 = casadi__IMatrix__CONSTRUCTOR__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__6" c_casadi__IMatrix__CONSTRUCTOR__6 - :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') -casadi__IMatrix__CONSTRUCTOR__6 - :: IO IMatrix -casadi__IMatrix__CONSTRUCTOR__6 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__CONSTRUCTOR__6 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix__6 :: IO IMatrix -imatrix__6 = casadi__IMatrix__CONSTRUCTOR__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__T" c_casadi__IMatrix__T - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__T - :: IMatrix -> IO IMatrix -casadi__IMatrix__T x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__T errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_T :: IMatrixClass a => a -> IO IMatrix -imatrix_T x = casadi__IMatrix__T (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix____constpow__" c_casadi__IMatrix____constpow__ - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix____constpow__ - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix____constpow__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix____constpow__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix___constpow__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix___constpow__ x = casadi__IMatrix____constpow__ (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix____copysign__" c_casadi__IMatrix____copysign__ - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix____copysign__ - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix____copysign__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix____copysign__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix___copysign__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix___copysign__ x = casadi__IMatrix____copysign__ (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix____mldivide__" c_casadi__IMatrix____mldivide__ - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix____mldivide__ - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix____mldivide__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix____mldivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix___mldivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix___mldivide__ x = casadi__IMatrix____mldivide__ (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix____mrdivide__" c_casadi__IMatrix____mrdivide__ - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix____mrdivide__ - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix____mrdivide__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix____mrdivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix___mrdivide__ :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix___mrdivide__ x = casadi__IMatrix____mrdivide__ (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix____nonzero__" c_casadi__IMatrix____nonzero__ - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix____nonzero__ - :: IMatrix -> IO Bool -casadi__IMatrix____nonzero__ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix____nonzero__ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix___nonzero__ :: IMatrixClass a => a -> IO Bool -imatrix___nonzero__ x = casadi__IMatrix____nonzero__ (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix____truediv____0" c_casadi__IMatrix____truediv____0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix____truediv____0 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix____truediv____0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix____truediv____0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix___truediv____0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix___truediv____0 x = casadi__IMatrix____truediv____0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix____truediv____1" c_casadi__IMatrix____truediv____1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix____truediv____1 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix____truediv____1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix____truediv____1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix___truediv____1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix___truediv____1 x = casadi__IMatrix____truediv____1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__append" c_casadi__IMatrix__append - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__append - :: IMatrix -> IMatrix -> IO () -casadi__IMatrix__append x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__append errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_append :: IMatrixClass a => a -> IMatrix -> IO () -imatrix_append x = casadi__IMatrix__append (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__appendColumns" c_casadi__IMatrix__appendColumns - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__appendColumns - :: IMatrix -> IMatrix -> IO () -casadi__IMatrix__appendColumns x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__appendColumns errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_appendColumns :: IMatrixClass a => a -> IMatrix -> IO () -imatrix_appendColumns x = casadi__IMatrix__appendColumns (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__binary" c_casadi__IMatrix__binary - :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__binary - :: Int -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__binary x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__binary errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_binary :: Int -> IMatrix -> IMatrix -> IO IMatrix -imatrix_binary = casadi__IMatrix__binary - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__className" c_casadi__IMatrix__className - :: Ptr (Ptr StdString) -> IO (Ptr StdString) -casadi__IMatrix__className - :: IO String -casadi__IMatrix__className = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__className errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_className :: IO String -imatrix_className = casadi__IMatrix__className - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__clear" c_casadi__IMatrix__clear - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__clear - :: IMatrix -> IO () -casadi__IMatrix__clear x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__clear errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_clear :: IMatrixClass a => a -> IO () -imatrix_clear x = casadi__IMatrix__clear (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__colind" c_casadi__IMatrix__colind - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__colind - :: IMatrix -> Int -> IO Int -casadi__IMatrix__colind x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__colind errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_colind :: IMatrixClass a => a -> Int -> IO Int -imatrix_colind x = casadi__IMatrix__colind (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__dimString" c_casadi__IMatrix__dimString - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) -casadi__IMatrix__dimString - :: IMatrix -> IO String -casadi__IMatrix__dimString x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__dimString errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_dimString :: IMatrixClass a => a -> IO String -imatrix_dimString x = casadi__IMatrix__dimString (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__enlarge__0" c_casadi__IMatrix__enlarge__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__IMatrix__enlarge__0 - :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () -casadi__IMatrix__enlarge__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_enlarge__0 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () -imatrix_enlarge__0 x = casadi__IMatrix__enlarge__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__enlarge__1" c_casadi__IMatrix__enlarge__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__IMatrix__enlarge__1 - :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -casadi__IMatrix__enlarge__1 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_enlarge__1 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -imatrix_enlarge__1 x = casadi__IMatrix__enlarge__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__erase__0" c_casadi__IMatrix__erase__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO () -casadi__IMatrix__erase__0 - :: IMatrix -> Vector Int -> IO () -casadi__IMatrix__erase__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__erase__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_erase__0 :: IMatrixClass a => a -> Vector Int -> IO () -imatrix_erase__0 x = casadi__IMatrix__erase__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__erase__1" c_casadi__IMatrix__erase__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__IMatrix__erase__1 - :: IMatrix -> Vector Int -> Bool -> IO () -casadi__IMatrix__erase__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__erase__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_erase__1 :: IMatrixClass a => a -> Vector Int -> Bool -> IO () -imatrix_erase__1 x = casadi__IMatrix__erase__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__erase__2" c_casadi__IMatrix__erase__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__IMatrix__erase__2 - :: IMatrix -> Vector Int -> Vector Int -> IO () -casadi__IMatrix__erase__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__erase__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_erase__2 :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () -imatrix_erase__2 x = casadi__IMatrix__erase__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__erase__3" c_casadi__IMatrix__erase__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__IMatrix__erase__3 - :: IMatrix -> Vector Int -> Vector Int -> Bool -> IO () -casadi__IMatrix__erase__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__erase__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_erase__3 :: IMatrixClass a => a -> Vector Int -> Vector Int -> Bool -> IO () -imatrix_erase__3 x = casadi__IMatrix__erase__3 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__eye" c_casadi__IMatrix__eye - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__eye - :: Int -> IO IMatrix -casadi__IMatrix__eye x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__eye errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_eye :: Int -> IO IMatrix -imatrix_eye = casadi__IMatrix__eye - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__find__0" c_casadi__IMatrix__find__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) -casadi__IMatrix__find__0 - :: IMatrix -> IO (Vector Int) -casadi__IMatrix__find__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__find__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_find__0 :: IMatrixClass a => a -> IO (Vector Int) -imatrix_find__0 x = casadi__IMatrix__find__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__find__1" c_casadi__IMatrix__find__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec CInt)) -casadi__IMatrix__find__1 - :: IMatrix -> Bool -> IO (Vector Int) -casadi__IMatrix__find__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__find__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_find__1 :: IMatrixClass a => a -> Bool -> IO (Vector Int) -imatrix_find__1 x = casadi__IMatrix__find__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__0" c_casadi__IMatrix__get__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__get__0 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () -casadi__IMatrix__get__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () -imatrix_get__0 x = casadi__IMatrix__get__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__1" c_casadi__IMatrix__get__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__IMatrix__get__1 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO () -casadi__IMatrix__get__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> IO () -imatrix_get__1 x = casadi__IMatrix__get__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__2" c_casadi__IMatrix__get__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__IMatrix__get__2 - :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO () -casadi__IMatrix__get__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> IO () -imatrix_get__2 x = casadi__IMatrix__get__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__3" c_casadi__IMatrix__get__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__IMatrix__get__3 - :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO () -casadi__IMatrix__get__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> IO () -imatrix_get__3 x = casadi__IMatrix__get__3 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__4" c_casadi__IMatrix__get__4 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO () -casadi__IMatrix__get__4 - :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO () -casadi__IMatrix__get__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> IO () -imatrix_get__4 x = casadi__IMatrix__get__4 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__5" c_casadi__IMatrix__get__5 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__IMatrix__get__5 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () -casadi__IMatrix__get__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () -imatrix_get__5 x = casadi__IMatrix__get__5 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__6" c_casadi__IMatrix__get__6 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__IMatrix__get__6 - :: IMatrix -> IMatrix -> Bool -> Slice -> IO () -casadi__IMatrix__get__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () -imatrix_get__6 x = casadi__IMatrix__get__6 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__get__7" c_casadi__IMatrix__get__7 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__IMatrix__get__7 - :: IMatrix -> Vector Double -> IO () -casadi__IMatrix__get__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__get__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_get__7 :: IMatrixClass a => a -> Vector Double -> IO () -imatrix_get__7 x = casadi__IMatrix__get__7 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getColind" c_casadi__IMatrix__getColind - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) -casadi__IMatrix__getColind - :: IMatrix -> IO (Vector Int) -casadi__IMatrix__getColind x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getColind errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getColind :: IMatrixClass a => a -> IO (Vector Int) -imatrix_getColind x = casadi__IMatrix__getColind (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getDep__0" c_casadi__IMatrix__getDep__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__getDep__0 - :: IMatrix -> IO IMatrix -casadi__IMatrix__getDep__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getDep__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getDep__0 :: IMatrixClass a => a -> IO IMatrix -imatrix_getDep__0 x = casadi__IMatrix__getDep__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getDep__1" c_casadi__IMatrix__getDep__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__getDep__1 - :: IMatrix -> Int -> IO IMatrix -casadi__IMatrix__getDep__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getDep__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getDep__1 :: IMatrixClass a => a -> Int -> IO IMatrix -imatrix_getDep__1 x = casadi__IMatrix__getDep__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getElementHash" c_casadi__IMatrix__getElementHash - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CLong -casadi__IMatrix__getElementHash - :: IMatrix -> IO Int -casadi__IMatrix__getElementHash x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getElementHash errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getElementHash :: IMatrixClass a => a -> IO Int -imatrix_getElementHash x = casadi__IMatrix__getElementHash (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getEqualityCheckingDepth" c_casadi__IMatrix__getEqualityCheckingDepth - :: Ptr (Ptr StdString) -> IO CInt -casadi__IMatrix__getEqualityCheckingDepth - :: IO Int -casadi__IMatrix__getEqualityCheckingDepth = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getEqualityCheckingDepth errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getEqualityCheckingDepth :: IO Int -imatrix_getEqualityCheckingDepth = casadi__IMatrix__getEqualityCheckingDepth - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getIntValue" c_casadi__IMatrix__getIntValue - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__getIntValue - :: IMatrix -> IO Int -casadi__IMatrix__getIntValue x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getIntValue errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getIntValue :: IMatrixClass a => a -> IO Int -imatrix_getIntValue x = casadi__IMatrix__getIntValue (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getMaxNumCallsInPrint" c_casadi__IMatrix__getMaxNumCallsInPrint - :: Ptr (Ptr StdString) -> IO CLong -casadi__IMatrix__getMaxNumCallsInPrint - :: IO Int -casadi__IMatrix__getMaxNumCallsInPrint = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getMaxNumCallsInPrint errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getMaxNumCallsInPrint :: IO Int -imatrix_getMaxNumCallsInPrint = casadi__IMatrix__getMaxNumCallsInPrint - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getNZ__0" c_casadi__IMatrix__getNZ__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__IMatrix__getNZ__0 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () -casadi__IMatrix__getNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () -imatrix_getNZ__0 x = casadi__IMatrix__getNZ__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getNZ__1" c_casadi__IMatrix__getNZ__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__IMatrix__getNZ__1 - :: IMatrix -> IMatrix -> Bool -> Slice -> IO () -casadi__IMatrix__getNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () -imatrix_getNZ__1 x = casadi__IMatrix__getNZ__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getNZ__2" c_casadi__IMatrix__getNZ__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__IMatrix__getNZ__2 - :: IMatrix -> Vector Double -> IO () -casadi__IMatrix__getNZ__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getNZ__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getNZ__2 :: IMatrixClass a => a -> Vector Double -> IO () -imatrix_getNZ__2 x = casadi__IMatrix__getNZ__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getName" c_casadi__IMatrix__getName - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) -casadi__IMatrix__getName - :: IMatrix -> IO String -casadi__IMatrix__getName x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getName errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getName :: IMatrixClass a => a -> IO String -imatrix_getName x = casadi__IMatrix__getName (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getNdeps" c_casadi__IMatrix__getNdeps - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__getNdeps - :: IMatrix -> IO Int -casadi__IMatrix__getNdeps x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getNdeps errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getNdeps :: IMatrixClass a => a -> IO Int -imatrix_getNdeps x = casadi__IMatrix__getNdeps (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getRow" c_casadi__IMatrix__getRow - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) -casadi__IMatrix__getRow - :: IMatrix -> IO (Vector Int) -casadi__IMatrix__getRow x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getRow errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getRow :: IMatrixClass a => a -> IO (Vector Int) -imatrix_getRow x = casadi__IMatrix__getRow (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getSparsity" c_casadi__IMatrix__getSparsity - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') -casadi__IMatrix__getSparsity - :: IMatrix -> IO Sparsity -casadi__IMatrix__getSparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getSparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getSparsity :: IMatrixClass a => a -> IO Sparsity -imatrix_getSparsity x = casadi__IMatrix__getSparsity (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getSym" c_casadi__IMatrix__getSym - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__IMatrix__getSym - :: IMatrix -> Vector Double -> IO () -casadi__IMatrix__getSym x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getSym errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getSym :: IMatrixClass a => a -> Vector Double -> IO () -imatrix_getSym x = casadi__IMatrix__getSym (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getValue__0" c_casadi__IMatrix__getValue__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CDouble -casadi__IMatrix__getValue__0 - :: IMatrix -> Int -> IO Double -casadi__IMatrix__getValue__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getValue__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getValue__0 :: IMatrixClass a => a -> Int -> IO Double -imatrix_getValue__0 x = casadi__IMatrix__getValue__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__getValue__1" c_casadi__IMatrix__getValue__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CDouble -casadi__IMatrix__getValue__1 - :: IMatrix -> IO Double -casadi__IMatrix__getValue__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__getValue__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_getValue__1 :: IMatrixClass a => a -> IO Double -imatrix_getValue__1 x = casadi__IMatrix__getValue__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__hasNZ" c_casadi__IMatrix__hasNZ - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt -casadi__IMatrix__hasNZ - :: IMatrix -> Int -> Int -> IO Bool -casadi__IMatrix__hasNZ x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__hasNZ errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_hasNZ :: IMatrixClass a => a -> Int -> Int -> IO Bool -imatrix_hasNZ x = casadi__IMatrix__hasNZ (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__hasNonStructuralZeros" c_casadi__IMatrix__hasNonStructuralZeros - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__hasNonStructuralZeros - :: IMatrix -> IO Bool -casadi__IMatrix__hasNonStructuralZeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__hasNonStructuralZeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_hasNonStructuralZeros :: IMatrixClass a => a -> IO Bool -imatrix_hasNonStructuralZeros x = casadi__IMatrix__hasNonStructuralZeros (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__inf__0" c_casadi__IMatrix__inf__0 - :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') -casadi__IMatrix__inf__0 - :: IO IMatrix -casadi__IMatrix__inf__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__inf__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_inf__0 :: IO IMatrix -imatrix_inf__0 = casadi__IMatrix__inf__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__inf__1" c_casadi__IMatrix__inf__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__inf__1 - :: Int -> IO IMatrix -casadi__IMatrix__inf__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__inf__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_inf__1 :: Int -> IO IMatrix -imatrix_inf__1 = casadi__IMatrix__inf__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__inf__2" c_casadi__IMatrix__inf__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__inf__2 - :: Int -> Int -> IO IMatrix -casadi__IMatrix__inf__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__inf__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_inf__2 :: Int -> Int -> IO IMatrix -imatrix_inf__2 = casadi__IMatrix__inf__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__inf__3" c_casadi__IMatrix__inf__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__inf__3 - :: Sparsity -> IO IMatrix -casadi__IMatrix__inf__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__inf__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_inf__3 :: Sparsity -> IO IMatrix -imatrix_inf__3 = casadi__IMatrix__inf__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isCommutative" c_casadi__IMatrix__isCommutative - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isCommutative - :: IMatrix -> IO Bool -casadi__IMatrix__isCommutative x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isCommutative errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isCommutative :: IMatrixClass a => a -> IO Bool -imatrix_isCommutative x = casadi__IMatrix__isCommutative (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isConstant" c_casadi__IMatrix__isConstant - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isConstant - :: IMatrix -> IO Bool -casadi__IMatrix__isConstant x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isConstant errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isConstant :: IMatrixClass a => a -> IO Bool -imatrix_isConstant x = casadi__IMatrix__isConstant (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isDense" c_casadi__IMatrix__isDense - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isDense - :: IMatrix -> IO Bool -casadi__IMatrix__isDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isDense :: IMatrixClass a => a -> IO Bool -imatrix_isDense x = casadi__IMatrix__isDense (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isEmpty__0" c_casadi__IMatrix__isEmpty__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isEmpty__0 - :: IMatrix -> IO Bool -casadi__IMatrix__isEmpty__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isEmpty__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isEmpty__0 :: IMatrixClass a => a -> IO Bool -imatrix_isEmpty__0 x = casadi__IMatrix__isEmpty__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isEmpty__1" c_casadi__IMatrix__isEmpty__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__isEmpty__1 - :: IMatrix -> Bool -> IO Bool -casadi__IMatrix__isEmpty__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isEmpty__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isEmpty__1 :: IMatrixClass a => a -> Bool -> IO Bool -imatrix_isEmpty__1 x = casadi__IMatrix__isEmpty__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isIdentity" c_casadi__IMatrix__isIdentity - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isIdentity - :: IMatrix -> IO Bool -casadi__IMatrix__isIdentity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isIdentity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isIdentity :: IMatrixClass a => a -> IO Bool -imatrix_isIdentity x = casadi__IMatrix__isIdentity (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isInteger" c_casadi__IMatrix__isInteger - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isInteger - :: IMatrix -> IO Bool -casadi__IMatrix__isInteger x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isInteger errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isInteger :: IMatrixClass a => a -> IO Bool -imatrix_isInteger x = casadi__IMatrix__isInteger (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isLeaf" c_casadi__IMatrix__isLeaf - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isLeaf - :: IMatrix -> IO Bool -casadi__IMatrix__isLeaf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isLeaf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isLeaf :: IMatrixClass a => a -> IO Bool -imatrix_isLeaf x = casadi__IMatrix__isLeaf (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isMinusOne" c_casadi__IMatrix__isMinusOne - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isMinusOne - :: IMatrix -> IO Bool -casadi__IMatrix__isMinusOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isMinusOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isMinusOne :: IMatrixClass a => a -> IO Bool -imatrix_isMinusOne x = casadi__IMatrix__isMinusOne (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isOne" c_casadi__IMatrix__isOne - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isOne - :: IMatrix -> IO Bool -casadi__IMatrix__isOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isOne :: IMatrixClass a => a -> IO Bool -imatrix_isOne x = casadi__IMatrix__isOne (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isRegular" c_casadi__IMatrix__isRegular - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isRegular - :: IMatrix -> IO Bool -casadi__IMatrix__isRegular x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isRegular errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isRegular :: IMatrixClass a => a -> IO Bool -imatrix_isRegular x = casadi__IMatrix__isRegular (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isRowVector" c_casadi__IMatrix__isRowVector - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isRowVector - :: IMatrix -> IO Bool -casadi__IMatrix__isRowVector x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isRowVector errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isRowVector :: IMatrixClass a => a -> IO Bool -imatrix_isRowVector x = casadi__IMatrix__isRowVector (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isScalar__0" c_casadi__IMatrix__isScalar__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isScalar__0 - :: IMatrix -> IO Bool -casadi__IMatrix__isScalar__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isScalar__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isScalar__0 :: IMatrixClass a => a -> IO Bool -imatrix_isScalar__0 x = casadi__IMatrix__isScalar__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isScalar__1" c_casadi__IMatrix__isScalar__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__isScalar__1 - :: IMatrix -> Bool -> IO Bool -casadi__IMatrix__isScalar__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isScalar__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isScalar__1 :: IMatrixClass a => a -> Bool -> IO Bool -imatrix_isScalar__1 x = casadi__IMatrix__isScalar__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isSlice__0" c_casadi__IMatrix__isSlice__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isSlice__0 - :: IMatrix -> IO Bool -casadi__IMatrix__isSlice__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isSlice__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isSlice__0 :: IMatrixClass a => a -> IO Bool -imatrix_isSlice__0 x = casadi__IMatrix__isSlice__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isSlice__1" c_casadi__IMatrix__isSlice__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__isSlice__1 - :: IMatrix -> Bool -> IO Bool -casadi__IMatrix__isSlice__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isSlice__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isSlice__1 :: IMatrixClass a => a -> Bool -> IO Bool -imatrix_isSlice__1 x = casadi__IMatrix__isSlice__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isSmooth" c_casadi__IMatrix__isSmooth - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isSmooth - :: IMatrix -> IO Bool -casadi__IMatrix__isSmooth x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isSmooth errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isSmooth :: IMatrixClass a => a -> IO Bool -imatrix_isSmooth x = casadi__IMatrix__isSmooth (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isSquare" c_casadi__IMatrix__isSquare - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isSquare - :: IMatrix -> IO Bool -casadi__IMatrix__isSquare x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isSquare errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isSquare :: IMatrixClass a => a -> IO Bool -imatrix_isSquare x = casadi__IMatrix__isSquare (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isSymbolic" c_casadi__IMatrix__isSymbolic - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isSymbolic - :: IMatrix -> IO Bool -casadi__IMatrix__isSymbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isSymbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isSymbolic :: IMatrixClass a => a -> IO Bool -imatrix_isSymbolic x = casadi__IMatrix__isSymbolic (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isSymbolicSparse" c_casadi__IMatrix__isSymbolicSparse - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isSymbolicSparse - :: IMatrix -> IO Bool -casadi__IMatrix__isSymbolicSparse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isSymbolicSparse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isSymbolicSparse :: IMatrixClass a => a -> IO Bool -imatrix_isSymbolicSparse x = casadi__IMatrix__isSymbolicSparse (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isTril" c_casadi__IMatrix__isTril - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isTril - :: IMatrix -> IO Bool -casadi__IMatrix__isTril x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isTril errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isTril :: IMatrixClass a => a -> IO Bool -imatrix_isTril x = casadi__IMatrix__isTril (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isTriu" c_casadi__IMatrix__isTriu - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isTriu - :: IMatrix -> IO Bool -casadi__IMatrix__isTriu x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isTriu errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isTriu :: IMatrixClass a => a -> IO Bool -imatrix_isTriu x = casadi__IMatrix__isTriu (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isVector__0" c_casadi__IMatrix__isVector__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isVector__0 - :: IMatrix -> IO Bool -casadi__IMatrix__isVector__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isVector__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isVector__0 :: IMatrixClass a => a -> IO Bool -imatrix_isVector__0 x = casadi__IMatrix__isVector__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isVector__1" c_casadi__IMatrix__isVector__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__isVector__1 - :: IMatrix -> Bool -> IO Bool -casadi__IMatrix__isVector__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isVector__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isVector__1 :: IMatrixClass a => a -> Bool -> IO Bool -imatrix_isVector__1 x = casadi__IMatrix__isVector__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__isZero" c_casadi__IMatrix__isZero - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__isZero - :: IMatrix -> IO Bool -casadi__IMatrix__isZero x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__isZero errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_isZero :: IMatrixClass a => a -> IO Bool -imatrix_isZero x = casadi__IMatrix__isZero (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__makeSparse__0" c_casadi__IMatrix__makeSparse__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__makeSparse__0 - :: IMatrix -> IO () -casadi__IMatrix__makeSparse__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__makeSparse__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_makeSparse__0 :: IMatrixClass a => a -> IO () -imatrix_makeSparse__0 x = casadi__IMatrix__makeSparse__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__makeSparse__1" c_casadi__IMatrix__makeSparse__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () -casadi__IMatrix__makeSparse__1 - :: IMatrix -> Double -> IO () -casadi__IMatrix__makeSparse__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__makeSparse__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_makeSparse__1 :: IMatrixClass a => a -> Double -> IO () -imatrix_makeSparse__1 x = casadi__IMatrix__makeSparse__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__matrix_matrix" c_casadi__IMatrix__matrix_matrix - :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__matrix_matrix - :: Int -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__matrix_matrix x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__matrix_matrix errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix -imatrix_matrix_matrix = casadi__IMatrix__matrix_matrix - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__matrix_scalar" c_casadi__IMatrix__matrix_scalar - :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__matrix_scalar - :: Int -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__matrix_scalar x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__matrix_scalar errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix -imatrix_matrix_scalar = casadi__IMatrix__matrix_scalar - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__nan__0" c_casadi__IMatrix__nan__0 - :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') -casadi__IMatrix__nan__0 - :: IO IMatrix -casadi__IMatrix__nan__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__nan__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_nan__0 :: IO IMatrix -imatrix_nan__0 = casadi__IMatrix__nan__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__nan__1" c_casadi__IMatrix__nan__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__nan__1 - :: Int -> IO IMatrix -casadi__IMatrix__nan__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__nan__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_nan__1 :: Int -> IO IMatrix -imatrix_nan__1 = casadi__IMatrix__nan__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__nan__2" c_casadi__IMatrix__nan__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__nan__2 - :: Int -> Int -> IO IMatrix -casadi__IMatrix__nan__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__nan__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_nan__2 :: Int -> Int -> IO IMatrix -imatrix_nan__2 = casadi__IMatrix__nan__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__nan__3" c_casadi__IMatrix__nan__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__nan__3 - :: Sparsity -> IO IMatrix -casadi__IMatrix__nan__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__nan__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_nan__3 :: Sparsity -> IO IMatrix -imatrix_nan__3 = casadi__IMatrix__nan__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__nnz" c_casadi__IMatrix__nnz - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__nnz - :: IMatrix -> IO Int -casadi__IMatrix__nnz x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__nnz errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_nnz :: IMatrixClass a => a -> IO Int -imatrix_nnz x = casadi__IMatrix__nnz (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__nonzeros" c_casadi__IMatrix__nonzeros - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CDouble)) -casadi__IMatrix__nonzeros - :: IMatrix -> IO (Vector Double) -casadi__IMatrix__nonzeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__nonzeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_nonzeros :: IMatrixClass a => a -> IO (Vector Double) -imatrix_nonzeros x = casadi__IMatrix__nonzeros (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__nonzeros_int" c_casadi__IMatrix__nonzeros_int - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) -casadi__IMatrix__nonzeros_int - :: IMatrix -> IO (Vector Int) -casadi__IMatrix__nonzeros_int x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__nonzeros_int errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_nonzeros_int :: IMatrixClass a => a -> IO (Vector Int) -imatrix_nonzeros_int x = casadi__IMatrix__nonzeros_int (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__numel__0" c_casadi__IMatrix__numel__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__numel__0 - :: IMatrix -> Int -> IO Int -casadi__IMatrix__numel__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__numel__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_numel__0 :: IMatrixClass a => a -> Int -> IO Int -imatrix_numel__0 x = casadi__IMatrix__numel__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__numel__1" c_casadi__IMatrix__numel__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__numel__1 - :: IMatrix -> IO Int -casadi__IMatrix__numel__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__numel__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_numel__1 :: IMatrixClass a => a -> IO Int -imatrix_numel__1 x = casadi__IMatrix__numel__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__ones__0" c_casadi__IMatrix__ones__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__ones__0 - :: Sparsity -> IO IMatrix -casadi__IMatrix__ones__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__ones__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_ones__0 :: Sparsity -> IO IMatrix -imatrix_ones__0 = casadi__IMatrix__ones__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__ones__1" c_casadi__IMatrix__ones__1 - :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') -casadi__IMatrix__ones__1 - :: IO IMatrix -casadi__IMatrix__ones__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__ones__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_ones__1 :: IO IMatrix -imatrix_ones__1 = casadi__IMatrix__ones__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__ones__2" c_casadi__IMatrix__ones__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__ones__2 - :: Int -> IO IMatrix -casadi__IMatrix__ones__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__ones__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_ones__2 :: Int -> IO IMatrix -imatrix_ones__2 = casadi__IMatrix__ones__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__ones__3" c_casadi__IMatrix__ones__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__ones__3 - :: Int -> Int -> IO IMatrix -casadi__IMatrix__ones__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__ones__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_ones__3 :: Int -> Int -> IO IMatrix -imatrix_ones__3 = casadi__IMatrix__ones__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__operator_plus" c_casadi__IMatrix__operator_plus - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__operator_plus - :: IMatrix -> IO IMatrix -casadi__IMatrix__operator_plus x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__operator_plus errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_operator_plus :: IMatrixClass a => a -> IO IMatrix -imatrix_operator_plus x = casadi__IMatrix__operator_plus (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__operator_minus" c_casadi__IMatrix__operator_minus - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__operator_minus - :: IMatrix -> IO IMatrix -casadi__IMatrix__operator_minus x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__operator_minus errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_operator_minus :: IMatrixClass a => a -> IO IMatrix -imatrix_operator_minus x = casadi__IMatrix__operator_minus (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__printDense" c_casadi__IMatrix__printDense - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__printDense - :: IMatrix -> IO () -casadi__IMatrix__printDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__printDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_printDense :: IMatrixClass a => a -> IO () -imatrix_printDense x = casadi__IMatrix__printDense (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__printScalar" c_casadi__IMatrix__printScalar - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__printScalar - :: IMatrix -> IO () -casadi__IMatrix__printScalar x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__printScalar errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_printScalar :: IMatrixClass a => a -> IO () -imatrix_printScalar x = casadi__IMatrix__printScalar (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__printSparse" c_casadi__IMatrix__printSparse - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__printSparse - :: IMatrix -> IO () -casadi__IMatrix__printSparse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__printSparse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_printSparse :: IMatrixClass a => a -> IO () -imatrix_printSparse x = casadi__IMatrix__printSparse (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__printVector" c_casadi__IMatrix__printVector - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__printVector - :: IMatrix -> IO () -casadi__IMatrix__printVector x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__printVector errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_printVector :: IMatrixClass a => a -> IO () -imatrix_printVector x = casadi__IMatrix__printVector (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__printme" c_casadi__IMatrix__printme - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__printme - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__printme x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__printme errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_printme :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_printme x = casadi__IMatrix__printme (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__remove" c_casadi__IMatrix__remove - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__IMatrix__remove - :: IMatrix -> Vector Int -> Vector Int -> IO () -casadi__IMatrix__remove x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__remove errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_remove :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () -imatrix_remove x = casadi__IMatrix__remove (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__reserve__0" c_casadi__IMatrix__reserve__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () -casadi__IMatrix__reserve__0 - :: IMatrix -> Int -> Int -> IO () -casadi__IMatrix__reserve__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__reserve__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_reserve__0 :: IMatrixClass a => a -> Int -> Int -> IO () -imatrix_reserve__0 x = casadi__IMatrix__reserve__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__reserve__1" c_casadi__IMatrix__reserve__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () -casadi__IMatrix__reserve__1 - :: IMatrix -> Int -> IO () -casadi__IMatrix__reserve__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__reserve__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_reserve__1 :: IMatrixClass a => a -> Int -> IO () -imatrix_reserve__1 x = casadi__IMatrix__reserve__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__resize" c_casadi__IMatrix__resize - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () -casadi__IMatrix__resize - :: IMatrix -> Int -> Int -> IO () -casadi__IMatrix__resize x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__resize errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_resize :: IMatrixClass a => a -> Int -> Int -> IO () -imatrix_resize x = casadi__IMatrix__resize (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__row" c_casadi__IMatrix__row - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__row - :: IMatrix -> Int -> IO Int -casadi__IMatrix__row x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__row errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_row :: IMatrixClass a => a -> Int -> IO Int -imatrix_row x = casadi__IMatrix__row (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sanityCheck__0" c_casadi__IMatrix__sanityCheck__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__sanityCheck__0 - :: IMatrix -> IO () -casadi__IMatrix__sanityCheck__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sanityCheck__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sanityCheck__0 :: IMatrixClass a => a -> IO () -imatrix_sanityCheck__0 x = casadi__IMatrix__sanityCheck__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sanityCheck__1" c_casadi__IMatrix__sanityCheck__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () -casadi__IMatrix__sanityCheck__1 - :: IMatrix -> Bool -> IO () -casadi__IMatrix__sanityCheck__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sanityCheck__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sanityCheck__1 :: IMatrixClass a => a -> Bool -> IO () -imatrix_sanityCheck__1 x = casadi__IMatrix__sanityCheck__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__scalar_matrix" c_casadi__IMatrix__scalar_matrix - :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__scalar_matrix - :: Int -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__scalar_matrix x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__scalar_matrix errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix -imatrix_scalar_matrix = casadi__IMatrix__scalar_matrix - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__0" c_casadi__IMatrix__set__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__set__0 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () -casadi__IMatrix__set__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () -imatrix_set__0 x = casadi__IMatrix__set__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__1" c_casadi__IMatrix__set__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__IMatrix__set__1 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO () -casadi__IMatrix__set__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> IO () -imatrix_set__1 x = casadi__IMatrix__set__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__2" c_casadi__IMatrix__set__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__IMatrix__set__2 - :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO () -casadi__IMatrix__set__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> IO () -imatrix_set__2 x = casadi__IMatrix__set__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__3" c_casadi__IMatrix__set__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__IMatrix__set__3 - :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO () -casadi__IMatrix__set__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> IO () -imatrix_set__3 x = casadi__IMatrix__set__3 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__4" c_casadi__IMatrix__set__4 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO () -casadi__IMatrix__set__4 - :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO () -casadi__IMatrix__set__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> IO () -imatrix_set__4 x = casadi__IMatrix__set__4 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__5" c_casadi__IMatrix__set__5 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__IMatrix__set__5 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () -casadi__IMatrix__set__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () -imatrix_set__5 x = casadi__IMatrix__set__5 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__6" c_casadi__IMatrix__set__6 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__IMatrix__set__6 - :: IMatrix -> IMatrix -> Bool -> Slice -> IO () -casadi__IMatrix__set__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () -imatrix_set__6 x = casadi__IMatrix__set__6 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__7" c_casadi__IMatrix__set__7 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__IMatrix__set__7 - :: IMatrix -> Vector Double -> IO () -casadi__IMatrix__set__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__7 :: IMatrixClass a => a -> Vector Double -> IO () -imatrix_set__7 x = casadi__IMatrix__set__7 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__8" c_casadi__IMatrix__set__8 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__IMatrix__set__8 - :: IMatrix -> Vector Double -> Bool -> IO () -casadi__IMatrix__set__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__8 :: IMatrixClass a => a -> Vector Double -> Bool -> IO () -imatrix_set__8 x = casadi__IMatrix__set__8 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__9" c_casadi__IMatrix__set__9 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () -casadi__IMatrix__set__9 - :: IMatrix -> Double -> IO () -casadi__IMatrix__set__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__9 :: IMatrixClass a => a -> Double -> IO () -imatrix_set__9 x = casadi__IMatrix__set__9 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__set__10" c_casadi__IMatrix__set__10 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__set__10 - :: IMatrix -> IMatrix -> IO () -casadi__IMatrix__set__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__set__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_set__10 :: IMatrixClass a => a -> IMatrix -> IO () -imatrix_set__10 x = casadi__IMatrix__set__10 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__0" c_casadi__IMatrix__setEqualityCheckingDepth__0 - :: Ptr (Ptr StdString) -> IO () -casadi__IMatrix__setEqualityCheckingDepth__0 - :: IO () -casadi__IMatrix__setEqualityCheckingDepth__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setEqualityCheckingDepth__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setEqualityCheckingDepth__0 :: IO () -imatrix_setEqualityCheckingDepth__0 = casadi__IMatrix__setEqualityCheckingDepth__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__1" c_casadi__IMatrix__setEqualityCheckingDepth__1 - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__IMatrix__setEqualityCheckingDepth__1 - :: Int -> IO () -casadi__IMatrix__setEqualityCheckingDepth__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setEqualityCheckingDepth__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setEqualityCheckingDepth__1 :: Int -> IO () -imatrix_setEqualityCheckingDepth__1 = casadi__IMatrix__setEqualityCheckingDepth__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setMaxNumCallsInPrint__0" c_casadi__IMatrix__setMaxNumCallsInPrint__0 - :: Ptr (Ptr StdString) -> IO () -casadi__IMatrix__setMaxNumCallsInPrint__0 - :: IO () -casadi__IMatrix__setMaxNumCallsInPrint__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setMaxNumCallsInPrint__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setMaxNumCallsInPrint__0 :: IO () -imatrix_setMaxNumCallsInPrint__0 = casadi__IMatrix__setMaxNumCallsInPrint__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setMaxNumCallsInPrint__1" c_casadi__IMatrix__setMaxNumCallsInPrint__1 - :: Ptr (Ptr StdString) -> CLong -> IO () -casadi__IMatrix__setMaxNumCallsInPrint__1 - :: Int -> IO () -casadi__IMatrix__setMaxNumCallsInPrint__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setMaxNumCallsInPrint__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setMaxNumCallsInPrint__1 :: Int -> IO () -imatrix_setMaxNumCallsInPrint__1 = casadi__IMatrix__setMaxNumCallsInPrint__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setNZ__0" c_casadi__IMatrix__setNZ__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () -casadi__IMatrix__setNZ__0 - :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () -casadi__IMatrix__setNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () -imatrix_setNZ__0 x = casadi__IMatrix__setNZ__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setNZ__1" c_casadi__IMatrix__setNZ__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () -casadi__IMatrix__setNZ__1 - :: IMatrix -> IMatrix -> Bool -> Slice -> IO () -casadi__IMatrix__setNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () -imatrix_setNZ__1 x = casadi__IMatrix__setNZ__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setNZ__2" c_casadi__IMatrix__setNZ__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__IMatrix__setNZ__2 - :: IMatrix -> Vector Double -> IO () -casadi__IMatrix__setNZ__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setNZ__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setNZ__2 :: IMatrixClass a => a -> Vector Double -> IO () -imatrix_setNZ__2 x = casadi__IMatrix__setNZ__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setNZ__3" c_casadi__IMatrix__setNZ__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () -casadi__IMatrix__setNZ__3 - :: IMatrix -> Double -> IO () -casadi__IMatrix__setNZ__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setNZ__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setNZ__3 :: IMatrixClass a => a -> Double -> IO () -imatrix_setNZ__3 x = casadi__IMatrix__setNZ__3 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setPrecision" c_casadi__IMatrix__setPrecision - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__IMatrix__setPrecision - :: Int -> IO () -casadi__IMatrix__setPrecision x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setPrecision errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setPrecision :: Int -> IO () -imatrix_setPrecision = casadi__IMatrix__setPrecision - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setScientific" c_casadi__IMatrix__setScientific - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__IMatrix__setScientific - :: Bool -> IO () -casadi__IMatrix__setScientific x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setScientific errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setScientific :: Bool -> IO () -imatrix_setScientific = casadi__IMatrix__setScientific - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setSparse__0" c_casadi__IMatrix__setSparse__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__setSparse__0 - :: IMatrix -> Sparsity -> IO IMatrix -casadi__IMatrix__setSparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setSparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setSparse__0 :: IMatrixClass a => a -> Sparsity -> IO IMatrix -imatrix_setSparse__0 x = casadi__IMatrix__setSparse__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setSparse__1" c_casadi__IMatrix__setSparse__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__setSparse__1 - :: IMatrix -> Sparsity -> Bool -> IO IMatrix -casadi__IMatrix__setSparse__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setSparse__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setSparse__1 :: IMatrixClass a => a -> Sparsity -> Bool -> IO IMatrix -imatrix_setSparse__1 x = casadi__IMatrix__setSparse__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setSym" c_casadi__IMatrix__setSym - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () -casadi__IMatrix__setSym - :: IMatrix -> Vector Double -> IO () -casadi__IMatrix__setSym x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setSym errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setSym :: IMatrixClass a => a -> Vector Double -> IO () -imatrix_setSym x = casadi__IMatrix__setSym (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setValue__0" c_casadi__IMatrix__setValue__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> CInt -> IO () -casadi__IMatrix__setValue__0 - :: IMatrix -> Double -> Int -> IO () -casadi__IMatrix__setValue__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setValue__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setValue__0 :: IMatrixClass a => a -> Double -> Int -> IO () -imatrix_setValue__0 x = casadi__IMatrix__setValue__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setValue__1" c_casadi__IMatrix__setValue__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () -casadi__IMatrix__setValue__1 - :: IMatrix -> Double -> IO () -casadi__IMatrix__setValue__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setValue__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setValue__1 :: IMatrixClass a => a -> Double -> IO () -imatrix_setValue__1 x = casadi__IMatrix__setValue__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setWidth" c_casadi__IMatrix__setWidth - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__IMatrix__setWidth - :: Int -> IO () -casadi__IMatrix__setWidth x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setWidth errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setWidth :: Int -> IO () -imatrix_setWidth = casadi__IMatrix__setWidth - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__setZero" c_casadi__IMatrix__setZero - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__setZero - :: IMatrix -> IO () -casadi__IMatrix__setZero x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__setZero errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_setZero :: IMatrixClass a => a -> IO () -imatrix_setZero x = casadi__IMatrix__setZero (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__size__0" c_casadi__IMatrix__size__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__size__0 - :: IMatrix -> SparsityType -> IO Int -casadi__IMatrix__size__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__size__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_size__0 :: IMatrixClass a => a -> SparsityType -> IO Int -imatrix_size__0 x = casadi__IMatrix__size__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__size__1" c_casadi__IMatrix__size__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__size__1 - :: IMatrix -> IO Int -casadi__IMatrix__size__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__size__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_size__1 :: IMatrixClass a => a -> IO Int -imatrix_size__1 x = casadi__IMatrix__size__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__size1" c_casadi__IMatrix__size1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__size1 - :: IMatrix -> IO Int -casadi__IMatrix__size1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__size1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_size1 :: IMatrixClass a => a -> IO Int -imatrix_size1 x = casadi__IMatrix__size1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__size2" c_casadi__IMatrix__size2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__size2 - :: IMatrix -> IO Int -casadi__IMatrix__size2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__size2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_size2 :: IMatrixClass a => a -> IO Int -imatrix_size2 x = casadi__IMatrix__size2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sizeD" c_casadi__IMatrix__sizeD - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__sizeD - :: IMatrix -> IO Int -casadi__IMatrix__sizeD x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sizeD errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sizeD :: IMatrixClass a => a -> IO Int -imatrix_sizeD x = casadi__IMatrix__sizeD (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sizeL" c_casadi__IMatrix__sizeL - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__sizeL - :: IMatrix -> IO Int -casadi__IMatrix__sizeL x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sizeL errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sizeL :: IMatrixClass a => a -> IO Int -imatrix_sizeL x = casadi__IMatrix__sizeL (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sizeU" c_casadi__IMatrix__sizeU - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__sizeU - :: IMatrix -> IO Int -casadi__IMatrix__sizeU x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sizeU errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sizeU :: IMatrixClass a => a -> IO Int -imatrix_sizeU x = casadi__IMatrix__sizeU (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sparse__0" c_casadi__IMatrix__sparse__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__sparse__0 - :: Sparsity -> IMatrix -> IO IMatrix -casadi__IMatrix__sparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sparse__0 :: Sparsity -> IMatrix -> IO IMatrix -imatrix_sparse__0 = casadi__IMatrix__sparse__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sparse__1" c_casadi__IMatrix__sparse__1 - :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') -casadi__IMatrix__sparse__1 - :: IO IMatrix -casadi__IMatrix__sparse__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sparse__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sparse__1 :: IO IMatrix -imatrix_sparse__1 = casadi__IMatrix__sparse__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sparse__2" c_casadi__IMatrix__sparse__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__sparse__2 - :: Int -> IO IMatrix -casadi__IMatrix__sparse__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sparse__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sparse__2 :: Int -> IO IMatrix -imatrix_sparse__2 = casadi__IMatrix__sparse__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sparse__3" c_casadi__IMatrix__sparse__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__sparse__3 - :: Int -> Int -> IO IMatrix -casadi__IMatrix__sparse__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sparse__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sparse__3 :: Int -> Int -> IO IMatrix -imatrix_sparse__3 = casadi__IMatrix__sparse__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sparsity" c_casadi__IMatrix__sparsity - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') -casadi__IMatrix__sparsity - :: IMatrix -> IO Sparsity -casadi__IMatrix__sparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sparsity :: IMatrixClass a => a -> IO Sparsity -imatrix_sparsity x = casadi__IMatrix__sparsity (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sparsityRef" c_casadi__IMatrix__sparsityRef - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') -casadi__IMatrix__sparsityRef - :: IMatrix -> IO Sparsity -casadi__IMatrix__sparsityRef x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sparsityRef errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sparsityRef :: IMatrixClass a => a -> IO Sparsity -imatrix_sparsityRef x = casadi__IMatrix__sparsityRef (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__0" c_casadi__IMatrix__sym__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) -casadi__IMatrix__sym__0 - :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix)) -casadi__IMatrix__sym__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix)) -imatrix_sym__0 = casadi__IMatrix__sym__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__1" c_casadi__IMatrix__sym__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) -casadi__IMatrix__sym__1 - :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix)) -casadi__IMatrix__sym__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix)) -imatrix_sym__1 = casadi__IMatrix__sym__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__2" c_casadi__IMatrix__sym__2 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__sym__2 - :: String -> Int -> Int -> Int -> IO (Vector IMatrix) -casadi__IMatrix__sym__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector IMatrix) -imatrix_sym__2 = casadi__IMatrix__sym__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__3" c_casadi__IMatrix__sym__3 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__sym__3 - :: String -> Sparsity -> Int -> IO (Vector IMatrix) -casadi__IMatrix__sym__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector IMatrix) -imatrix_sym__3 = casadi__IMatrix__sym__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__4" c_casadi__IMatrix__sym__4 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__sym__4 - :: String -> Sparsity -> IO IMatrix -casadi__IMatrix__sym__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__4 :: String -> Sparsity -> IO IMatrix -imatrix_sym__4 = casadi__IMatrix__sym__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__5" c_casadi__IMatrix__sym__5 - :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr IMatrix') -casadi__IMatrix__sym__5 - :: String -> IO IMatrix -casadi__IMatrix__sym__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__5 :: String -> IO IMatrix -imatrix_sym__5 = casadi__IMatrix__sym__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__6" c_casadi__IMatrix__sym__6 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__sym__6 - :: String -> Int -> IO IMatrix -casadi__IMatrix__sym__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__6 :: String -> Int -> IO IMatrix -imatrix_sym__6 = casadi__IMatrix__sym__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__sym__7" c_casadi__IMatrix__sym__7 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__sym__7 - :: String -> Int -> Int -> IO IMatrix -casadi__IMatrix__sym__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__sym__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_sym__7 :: String -> Int -> Int -> IO IMatrix -imatrix_sym__7 = casadi__IMatrix__sym__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__toSlice__0" c_casadi__IMatrix__toSlice__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Slice') -casadi__IMatrix__toSlice__0 - :: IMatrix -> IO Slice -casadi__IMatrix__toSlice__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__toSlice__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_toSlice__0 :: IMatrixClass a => a -> IO Slice -imatrix_toSlice__0 x = casadi__IMatrix__toSlice__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__toSlice__1" c_casadi__IMatrix__toSlice__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr Slice') -casadi__IMatrix__toSlice__1 - :: IMatrix -> Bool -> IO Slice -casadi__IMatrix__toSlice__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__toSlice__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_toSlice__1 :: IMatrixClass a => a -> Bool -> IO Slice -imatrix_toSlice__1 x = casadi__IMatrix__toSlice__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__triplet__0" c_casadi__IMatrix__triplet__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__triplet__0 - :: Vector Int -> Vector Int -> IMatrix -> Int -> Int -> IO IMatrix -casadi__IMatrix__triplet__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__triplet__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_triplet__0 :: Vector Int -> Vector Int -> IMatrix -> Int -> Int -> IO IMatrix -imatrix_triplet__0 = casadi__IMatrix__triplet__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__triplet__1" c_casadi__IMatrix__triplet__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__triplet__1 - :: Vector Int -> Vector Int -> IMatrix -> IO IMatrix -casadi__IMatrix__triplet__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__triplet__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_triplet__1 :: Vector Int -> Vector Int -> IMatrix -> IO IMatrix -imatrix_triplet__1 = casadi__IMatrix__triplet__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__unary" c_casadi__IMatrix__unary - :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__unary - :: Int -> IMatrix -> IO IMatrix -casadi__IMatrix__unary x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__unary errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_unary :: Int -> IMatrix -> IO IMatrix -imatrix_unary = casadi__IMatrix__unary - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zeros__0" c_casadi__IMatrix__zeros__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__zeros__0 - :: Sparsity -> IO IMatrix -casadi__IMatrix__zeros__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zeros__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zeros__0 :: Sparsity -> IO IMatrix -imatrix_zeros__0 = casadi__IMatrix__zeros__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zeros__1" c_casadi__IMatrix__zeros__1 - :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') -casadi__IMatrix__zeros__1 - :: IO IMatrix -casadi__IMatrix__zeros__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zeros__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zeros__1 :: IO IMatrix -imatrix_zeros__1 = casadi__IMatrix__zeros__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zeros__2" c_casadi__IMatrix__zeros__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zeros__2 - :: Int -> IO IMatrix -casadi__IMatrix__zeros__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zeros__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zeros__2 :: Int -> IO IMatrix -imatrix_zeros__2 = casadi__IMatrix__zeros__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zeros__3" c_casadi__IMatrix__zeros__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zeros__3 - :: Int -> Int -> IO IMatrix -casadi__IMatrix__zeros__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zeros__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zeros__3 :: Int -> Int -> IO IMatrix -imatrix_zeros__3 = casadi__IMatrix__zeros__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_abs" c_casadi__IMatrix__zz_abs - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_abs - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_abs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_abs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_abs :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_abs x = casadi__IMatrix__zz_abs (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_acos" c_casadi__IMatrix__zz_acos - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_acos - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_acos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_acos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_acos :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_acos x = casadi__IMatrix__zz_acos (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_acosh" c_casadi__IMatrix__zz_acosh - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_acosh - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_acosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_acosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_acosh :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_acosh x = casadi__IMatrix__zz_acosh (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_adj" c_casadi__IMatrix__zz_adj - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_adj - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_adj x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_adj errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_adj :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_adj x = casadi__IMatrix__zz_adj (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_all" c_casadi__IMatrix__zz_all - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_all - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_all x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_all errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_all :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_all x = casadi__IMatrix__zz_all (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_and" c_casadi__IMatrix__zz_and - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_and - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_and x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_and errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_and :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_and x = casadi__IMatrix__zz_and (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_any" c_casadi__IMatrix__zz_any - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_any - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_any x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_any errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_any :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_any x = casadi__IMatrix__zz_any (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_asin" c_casadi__IMatrix__zz_asin - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_asin - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_asin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_asin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_asin :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_asin x = casadi__IMatrix__zz_asin (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_asinh" c_casadi__IMatrix__zz_asinh - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_asinh - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_asinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_asinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_asinh :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_asinh x = casadi__IMatrix__zz_asinh (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_atan" c_casadi__IMatrix__zz_atan - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_atan - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_atan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_atan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_atan :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_atan x = casadi__IMatrix__zz_atan (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_atan2" c_casadi__IMatrix__zz_atan2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_atan2 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_atan2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_atan2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_atan2 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_atan2 x = casadi__IMatrix__zz_atan2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_atanh" c_casadi__IMatrix__zz_atanh - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_atanh - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_atanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_atanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_atanh :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_atanh x = casadi__IMatrix__zz_atanh (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_blockcat" c_casadi__IMatrix__zz_blockcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))) -> IO (Ptr IMatrix') -casadi__IMatrix__zz_blockcat - :: Vector (Vector IMatrix) -> IO IMatrix -casadi__IMatrix__zz_blockcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_blockcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_blockcat :: Vector (Vector IMatrix) -> IO IMatrix -imatrix_zz_blockcat = casadi__IMatrix__zz_blockcat - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_blocksplit" c_casadi__IMatrix__zz_blocksplit - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) -casadi__IMatrix__zz_blocksplit - :: IMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix)) -casadi__IMatrix__zz_blocksplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_blocksplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_blocksplit :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix)) -imatrix_zz_blocksplit x = casadi__IMatrix__zz_blocksplit (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_ceil" c_casadi__IMatrix__zz_ceil - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_ceil - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_ceil x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_ceil errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_ceil :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_ceil x = casadi__IMatrix__zz_ceil (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_cofactor" c_casadi__IMatrix__zz_cofactor - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_cofactor - :: IMatrix -> Int -> Int -> IO IMatrix -casadi__IMatrix__zz_cofactor x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_cofactor errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_cofactor :: IMatrixClass a => a -> Int -> Int -> IO IMatrix -imatrix_zz_cofactor x = casadi__IMatrix__zz_cofactor (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_cos" c_casadi__IMatrix__zz_cos - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_cos - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_cos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_cos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_cos :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_cos x = casadi__IMatrix__zz_cos (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_cosh" c_casadi__IMatrix__zz_cosh - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_cosh - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_cosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_cosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_cosh :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_cosh x = casadi__IMatrix__zz_cosh (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_countNodes" c_casadi__IMatrix__zz_countNodes - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__zz_countNodes - :: IMatrix -> IO Int -casadi__IMatrix__zz_countNodes x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_countNodes errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_countNodes :: IMatrixClass a => a -> IO Int -imatrix_zz_countNodes x = casadi__IMatrix__zz_countNodes (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_cross__0" c_casadi__IMatrix__zz_cross__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_cross__0 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_cross__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_cross__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_cross__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_cross__0 x = casadi__IMatrix__zz_cross__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_cross__1" c_casadi__IMatrix__zz_cross__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_cross__1 - :: IMatrix -> IMatrix -> Int -> IO IMatrix -casadi__IMatrix__zz_cross__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_cross__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_cross__1 :: IMatrixClass a => a -> IMatrix -> Int -> IO IMatrix -imatrix_zz_cross__1 x = casadi__IMatrix__zz_cross__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_densify" c_casadi__IMatrix__zz_densify - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_densify - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_densify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_densify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_densify :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_densify x = casadi__IMatrix__zz_densify (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_dependsOn" c_casadi__IMatrix__zz_dependsOn - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__zz_dependsOn - :: IMatrix -> IMatrix -> IO Bool -casadi__IMatrix__zz_dependsOn x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_dependsOn errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_dependsOn :: IMatrixClass a => a -> IMatrix -> IO Bool -imatrix_zz_dependsOn x = casadi__IMatrix__zz_dependsOn (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_det" c_casadi__IMatrix__zz_det - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_det - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_det x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_det errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_det :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_det x = casadi__IMatrix__zz_det (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_diag" c_casadi__IMatrix__zz_diag - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_diag - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_diag x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_diag errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_diag :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_diag x = casadi__IMatrix__zz_diag (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_diagcat" c_casadi__IMatrix__zz_diagcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') -casadi__IMatrix__zz_diagcat - :: Vector IMatrix -> IO IMatrix -casadi__IMatrix__zz_diagcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_diagcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_diagcat :: Vector IMatrix -> IO IMatrix -imatrix_zz_diagcat = casadi__IMatrix__zz_diagcat - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_diagsplit" c_casadi__IMatrix__zz_diagsplit - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__zz_diagsplit - :: IMatrix -> Vector Int -> Vector Int -> IO (Vector IMatrix) -casadi__IMatrix__zz_diagsplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_diagsplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_diagsplit :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO (Vector IMatrix) -imatrix_zz_diagsplit x = casadi__IMatrix__zz_diagsplit (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_eig_symbolic" c_casadi__IMatrix__zz_eig_symbolic - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_eig_symbolic - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_eig_symbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_eig_symbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_eig_symbolic :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_eig_symbolic x = casadi__IMatrix__zz_eig_symbolic (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_eq" c_casadi__IMatrix__zz_eq - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_eq - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_eq x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_eq errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_eq :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_eq x = casadi__IMatrix__zz_eq (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_erf" c_casadi__IMatrix__zz_erf - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_erf - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_erf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_erf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_erf :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_erf x = casadi__IMatrix__zz_erf (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_erfinv" c_casadi__IMatrix__zz_erfinv - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_erfinv - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_erfinv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_erfinv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_erfinv :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_erfinv x = casadi__IMatrix__zz_erfinv (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_exp" c_casadi__IMatrix__zz_exp - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_exp - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_exp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_exp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_exp :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_exp x = casadi__IMatrix__zz_exp (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_expand" c_casadi__IMatrix__zz_expand - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__zz_expand - :: IMatrix -> IMatrix -> IMatrix -> IO () -casadi__IMatrix__zz_expand x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_expand errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_expand :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () -imatrix_zz_expand x = casadi__IMatrix__zz_expand (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_extractShared__0" c_casadi__IMatrix__zz_extractShared__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO () -casadi__IMatrix__zz_extractShared__0 - :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () -casadi__IMatrix__zz_extractShared__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_extractShared__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_extractShared__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () -imatrix_zz_extractShared__0 = casadi__IMatrix__zz_extractShared__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_extractShared__1" c_casadi__IMatrix__zz_extractShared__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> IO () -casadi__IMatrix__zz_extractShared__1 - :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> IO () -casadi__IMatrix__zz_extractShared__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_extractShared__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_extractShared__1 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> IO () -imatrix_zz_extractShared__1 = casadi__IMatrix__zz_extractShared__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_extractShared__2" c_casadi__IMatrix__zz_extractShared__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> Ptr StdString -> IO () -casadi__IMatrix__zz_extractShared__2 - :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> String -> IO () -casadi__IMatrix__zz_extractShared__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_extractShared__2 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> String -> IO () -imatrix_zz_extractShared__2 = casadi__IMatrix__zz_extractShared__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_floor" c_casadi__IMatrix__zz_floor - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_floor - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_floor x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_floor errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_floor :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_floor x = casadi__IMatrix__zz_floor (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_gauss_quadrature__0" c_casadi__IMatrix__zz_gauss_quadrature__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_gauss_quadrature__0 - :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_gauss_quadrature__0 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_gauss_quadrature__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> Int -> IMatrix -> IO IMatrix -imatrix_zz_gauss_quadrature__0 x = casadi__IMatrix__zz_gauss_quadrature__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_gauss_quadrature__1" c_casadi__IMatrix__zz_gauss_quadrature__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_gauss_quadrature__1 - :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_gauss_quadrature__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_gauss_quadrature__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_gauss_quadrature__1 x = casadi__IMatrix__zz_gauss_quadrature__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_gauss_quadrature__2" c_casadi__IMatrix__zz_gauss_quadrature__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_gauss_quadrature__2 - :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix -casadi__IMatrix__zz_gauss_quadrature__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_gauss_quadrature__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix -imatrix_zz_gauss_quadrature__2 x = casadi__IMatrix__zz_gauss_quadrature__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_ge" c_casadi__IMatrix__zz_ge - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_ge - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_ge x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_ge errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_ge :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_ge x = casadi__IMatrix__zz_ge (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_getMinor" c_casadi__IMatrix__zz_getMinor - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_getMinor - :: IMatrix -> Int -> Int -> IO IMatrix -casadi__IMatrix__zz_getMinor x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_getMinor errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_getMinor :: IMatrixClass a => a -> Int -> Int -> IO IMatrix -imatrix_zz_getMinor x = casadi__IMatrix__zz_getMinor (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_getOperatorRepresentation" c_casadi__IMatrix__zz_getOperatorRepresentation - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) -casadi__IMatrix__zz_getOperatorRepresentation - :: IMatrix -> Vector String -> IO String -casadi__IMatrix__zz_getOperatorRepresentation x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_getOperatorRepresentation errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_getOperatorRepresentation :: IMatrixClass a => a -> Vector String -> IO String -imatrix_zz_getOperatorRepresentation x = casadi__IMatrix__zz_getOperatorRepresentation (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_getSymbols__0" c_casadi__IMatrix__zz_getSymbols__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__zz_getSymbols__0 - :: Vector IMatrix -> IO (Vector IMatrix) -casadi__IMatrix__zz_getSymbols__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_getSymbols__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_getSymbols__0 :: Vector IMatrix -> IO (Vector IMatrix) -imatrix_zz_getSymbols__0 = casadi__IMatrix__zz_getSymbols__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_getSymbols__1" c_casadi__IMatrix__zz_getSymbols__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__zz_getSymbols__1 - :: IMatrix -> IO (Vector IMatrix) -casadi__IMatrix__zz_getSymbols__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_getSymbols__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_getSymbols__1 :: IMatrixClass a => a -> IO (Vector IMatrix) -imatrix_zz_getSymbols__1 x = casadi__IMatrix__zz_getSymbols__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_gradient" c_casadi__IMatrix__zz_gradient - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_gradient - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_gradient x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_gradient errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_gradient :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_gradient x = casadi__IMatrix__zz_gradient (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_gt" c_casadi__IMatrix__zz_gt - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_gt - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_gt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_gt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_gt :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_gt x = casadi__IMatrix__zz_gt (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_heaviside" c_casadi__IMatrix__zz_heaviside - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_heaviside - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_heaviside x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_heaviside errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_heaviside :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_heaviside x = casadi__IMatrix__zz_heaviside (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_hessian__0" c_casadi__IMatrix__zz_hessian__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__zz_hessian__0 - :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO () -casadi__IMatrix__zz_hessian__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_hessian__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_hessian__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IMatrix -> IO () -imatrix_zz_hessian__0 x = casadi__IMatrix__zz_hessian__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_hessian__1" c_casadi__IMatrix__zz_hessian__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_hessian__1 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_hessian__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_hessian__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_hessian__1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_hessian__1 x = casadi__IMatrix__zz_hessian__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_horzcat" c_casadi__IMatrix__zz_horzcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') -casadi__IMatrix__zz_horzcat - :: Vector IMatrix -> IO IMatrix -casadi__IMatrix__zz_horzcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_horzcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_horzcat :: Vector IMatrix -> IO IMatrix -imatrix_zz_horzcat = casadi__IMatrix__zz_horzcat - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_horzsplit" c_casadi__IMatrix__zz_horzsplit - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__zz_horzsplit - :: IMatrix -> Vector Int -> IO (Vector IMatrix) -casadi__IMatrix__zz_horzsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_horzsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_horzsplit :: IMatrixClass a => a -> Vector Int -> IO (Vector IMatrix) -imatrix_zz_horzsplit x = casadi__IMatrix__zz_horzsplit (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_if_else" c_casadi__IMatrix__zz_if_else - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_if_else - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_if_else x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_if_else errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_if_else :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_if_else x = casadi__IMatrix__zz_if_else (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_if_else_zero" c_casadi__IMatrix__zz_if_else_zero - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_if_else_zero - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_if_else_zero x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_if_else_zero errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_if_else_zero :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_if_else_zero x = casadi__IMatrix__zz_if_else_zero (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_inner_prod" c_casadi__IMatrix__zz_inner_prod - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_inner_prod - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_inner_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_inner_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_inner_prod :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_inner_prod x = casadi__IMatrix__zz_inner_prod (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_inv" c_casadi__IMatrix__zz_inv - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_inv - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_inv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_inv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_inv :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_inv x = casadi__IMatrix__zz_inv (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_isEqual__0" c_casadi__IMatrix__zz_isEqual__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__zz_isEqual__0 - :: IMatrix -> IMatrix -> IO Bool -casadi__IMatrix__zz_isEqual__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_isEqual__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_isEqual__0 :: IMatrixClass a => a -> IMatrix -> IO Bool -imatrix_zz_isEqual__0 x = casadi__IMatrix__zz_isEqual__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_isEqual__1" c_casadi__IMatrix__zz_isEqual__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO CInt -casadi__IMatrix__zz_isEqual__1 - :: IMatrix -> IMatrix -> Int -> IO Bool -casadi__IMatrix__zz_isEqual__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_isEqual__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_isEqual__1 :: IMatrixClass a => a -> IMatrix -> Int -> IO Bool -imatrix_zz_isEqual__1 x = casadi__IMatrix__zz_isEqual__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_jacobian" c_casadi__IMatrix__zz_jacobian - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_jacobian - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_jacobian x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_jacobian errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_jacobian :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_jacobian x = casadi__IMatrix__zz_jacobian (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_jacobianTimesVector__0" c_casadi__IMatrix__zz_jacobianTimesVector__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_jacobianTimesVector__0 - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_jacobianTimesVector__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_jacobianTimesVector__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_jacobianTimesVector__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_jacobianTimesVector__0 x = casadi__IMatrix__zz_jacobianTimesVector__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_jacobianTimesVector__1" c_casadi__IMatrix__zz_jacobianTimesVector__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_jacobianTimesVector__1 - :: IMatrix -> IMatrix -> IMatrix -> Bool -> IO IMatrix -casadi__IMatrix__zz_jacobianTimesVector__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_jacobianTimesVector__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_jacobianTimesVector__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Bool -> IO IMatrix -imatrix_zz_jacobianTimesVector__1 x = casadi__IMatrix__zz_jacobianTimesVector__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_kron" c_casadi__IMatrix__zz_kron - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_kron - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_kron x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_kron errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_kron :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_kron x = casadi__IMatrix__zz_kron (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_le" c_casadi__IMatrix__zz_le - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_le - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_le x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_le errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_le :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_le x = casadi__IMatrix__zz_le (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_linspace" c_casadi__IMatrix__zz_linspace - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_linspace - :: IMatrix -> IMatrix -> Int -> IO IMatrix -casadi__IMatrix__zz_linspace x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_linspace errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_linspace :: IMatrixClass a => a -> IMatrix -> Int -> IO IMatrix -imatrix_zz_linspace x = casadi__IMatrix__zz_linspace (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_log" c_casadi__IMatrix__zz_log - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_log - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_log x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_log errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_log :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_log x = casadi__IMatrix__zz_log (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_log10" c_casadi__IMatrix__zz_log10 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_log10 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_log10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_log10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_log10 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_log10 x = casadi__IMatrix__zz_log10 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_lt" c_casadi__IMatrix__zz_lt - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_lt - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_lt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_lt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_lt :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_lt x = casadi__IMatrix__zz_lt (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_max" c_casadi__IMatrix__zz_max - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_max - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_max x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_max errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_max :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_max x = casadi__IMatrix__zz_max (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_min" c_casadi__IMatrix__zz_min - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_min - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_min x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_min errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_min :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_min x = casadi__IMatrix__zz_min (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_minus" c_casadi__IMatrix__zz_minus - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_minus - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_minus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_minus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_minus :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_minus x = casadi__IMatrix__zz_minus (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_mod" c_casadi__IMatrix__zz_mod - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_mod - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_mod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_mod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_mod :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_mod x = casadi__IMatrix__zz_mod (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_mpower" c_casadi__IMatrix__zz_mpower - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_mpower - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_mpower x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_mpower errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_mpower :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_mpower x = casadi__IMatrix__zz_mpower (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_mtaylor__0" c_casadi__IMatrix__zz_mtaylor__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') -casadi__IMatrix__zz_mtaylor__0 - :: IMatrix -> IMatrix -> IMatrix -> Int -> Vector Int -> IO IMatrix -casadi__IMatrix__zz_mtaylor__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_mtaylor__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> Vector Int -> IO IMatrix -imatrix_zz_mtaylor__0 x = casadi__IMatrix__zz_mtaylor__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_mtaylor__1" c_casadi__IMatrix__zz_mtaylor__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_mtaylor__1 - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_mtaylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_mtaylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_mtaylor__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_mtaylor__1 x = casadi__IMatrix__zz_mtaylor__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_mtaylor__2" c_casadi__IMatrix__zz_mtaylor__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_mtaylor__2 - :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix -casadi__IMatrix__zz_mtaylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_mtaylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_mtaylor__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> IO IMatrix -imatrix_zz_mtaylor__2 x = casadi__IMatrix__zz_mtaylor__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_mtimes__0" c_casadi__IMatrix__zz_mtimes__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_mtimes__0 - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_mtimes__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_mtimes__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_mtimes__0 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_mtimes__0 x = casadi__IMatrix__zz_mtimes__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_mtimes__1" c_casadi__IMatrix__zz_mtimes__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_mtimes__1 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_mtimes__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_mtimes__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_mtimes__1 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_mtimes__1 x = casadi__IMatrix__zz_mtimes__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_ne" c_casadi__IMatrix__zz_ne - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_ne - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_ne x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_ne errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_ne :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_ne x = casadi__IMatrix__zz_ne (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_norm_0_mul" c_casadi__IMatrix__zz_norm_0_mul - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__zz_norm_0_mul - :: IMatrix -> IMatrix -> IO Int -casadi__IMatrix__zz_norm_0_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_norm_0_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_norm_0_mul :: IMatrixClass a => a -> IMatrix -> IO Int -imatrix_zz_norm_0_mul x = casadi__IMatrix__zz_norm_0_mul (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_norm_1" c_casadi__IMatrix__zz_norm_1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_norm_1 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_norm_1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_norm_1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_norm_1 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_norm_1 x = casadi__IMatrix__zz_norm_1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_norm_2" c_casadi__IMatrix__zz_norm_2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_norm_2 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_norm_2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_norm_2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_norm_2 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_norm_2 x = casadi__IMatrix__zz_norm_2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_norm_F" c_casadi__IMatrix__zz_norm_F - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_norm_F - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_norm_F x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_norm_F errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_norm_F :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_norm_F x = casadi__IMatrix__zz_norm_F (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_norm_inf" c_casadi__IMatrix__zz_norm_inf - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_norm_inf - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_norm_inf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_norm_inf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_norm_inf :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_norm_inf x = casadi__IMatrix__zz_norm_inf (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_norm_inf_mul" c_casadi__IMatrix__zz_norm_inf_mul - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_norm_inf_mul - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_norm_inf_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_norm_inf_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_norm_inf_mul :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_norm_inf_mul x = casadi__IMatrix__zz_norm_inf_mul (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_not" c_casadi__IMatrix__zz_not - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_not - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_not x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_not errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_not :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_not x = casadi__IMatrix__zz_not (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_nullspace" c_casadi__IMatrix__zz_nullspace - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_nullspace - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_nullspace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_nullspace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_nullspace :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_nullspace x = casadi__IMatrix__zz_nullspace (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_or" c_casadi__IMatrix__zz_or - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_or - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_or x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_or errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_or :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_or x = casadi__IMatrix__zz_or (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_outer_prod" c_casadi__IMatrix__zz_outer_prod - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_outer_prod - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_outer_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_outer_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_outer_prod :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_outer_prod x = casadi__IMatrix__zz_outer_prod (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_pinv" c_casadi__IMatrix__zz_pinv - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_pinv - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_pinv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_pinv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_pinv :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_pinv x = casadi__IMatrix__zz_pinv (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_plus" c_casadi__IMatrix__zz_plus - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_plus - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_plus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_plus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_plus :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_plus x = casadi__IMatrix__zz_plus (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_poly_coeff" c_casadi__IMatrix__zz_poly_coeff - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_poly_coeff - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_poly_coeff x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_poly_coeff errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_poly_coeff :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_poly_coeff x = casadi__IMatrix__zz_poly_coeff (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_poly_roots" c_casadi__IMatrix__zz_poly_roots - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_poly_roots - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_poly_roots x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_poly_roots errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_poly_roots :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_poly_roots x = casadi__IMatrix__zz_poly_roots (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_polyval" c_casadi__IMatrix__zz_polyval - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_polyval - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_polyval x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_polyval errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_polyval :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_polyval x = casadi__IMatrix__zz_polyval (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_power" c_casadi__IMatrix__zz_power - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_power - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_power x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_power errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_power :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_power x = casadi__IMatrix__zz_power (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_printCompact" c_casadi__IMatrix__zz_printCompact - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () -casadi__IMatrix__zz_printCompact - :: IMatrix -> IO () -casadi__IMatrix__zz_printCompact x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_printCompact errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_printCompact :: IMatrixClass a => a -> IO () -imatrix_zz_printCompact x = casadi__IMatrix__zz_printCompact (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_project" c_casadi__IMatrix__zz_project - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_project - :: IMatrix -> Sparsity -> IO IMatrix -casadi__IMatrix__zz_project x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_project errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_project :: IMatrixClass a => a -> Sparsity -> IO IMatrix -imatrix_zz_project x = casadi__IMatrix__zz_project (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_pw_const" c_casadi__IMatrix__zz_pw_const - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_pw_const - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_pw_const x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_pw_const errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_pw_const :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_pw_const x = casadi__IMatrix__zz_pw_const (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_pw_lin" c_casadi__IMatrix__zz_pw_lin - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_pw_lin - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_pw_lin x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_pw_lin errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_pw_lin :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_pw_lin x = casadi__IMatrix__zz_pw_lin (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_qr" c_casadi__IMatrix__zz_qr - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__IMatrix__zz_qr - :: IMatrix -> IMatrix -> IMatrix -> IO () -casadi__IMatrix__zz_qr x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_qr errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_qr :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO () -imatrix_zz_qr x = casadi__IMatrix__zz_qr (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__0" c_casadi__IMatrix__zz_quad_form__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_quad_form__0 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_quad_form__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_quad_form__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_quad_form__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_quad_form__0 x = casadi__IMatrix__zz_quad_form__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__1" c_casadi__IMatrix__zz_quad_form__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_quad_form__1 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_quad_form__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_quad_form__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_quad_form__1 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_quad_form__1 x = casadi__IMatrix__zz_quad_form__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__2" c_casadi__IMatrix__zz_quad_form__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_quad_form__2 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_quad_form__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_quad_form__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_quad_form__2 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_quad_form__2 x = casadi__IMatrix__zz_quad_form__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_quad_form__3" c_casadi__IMatrix__zz_quad_form__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_quad_form__3 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_quad_form__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_quad_form__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_quad_form__3 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_quad_form__3 x = casadi__IMatrix__zz_quad_form__3 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_ramp" c_casadi__IMatrix__zz_ramp - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_ramp - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_ramp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_ramp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_ramp :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_ramp x = casadi__IMatrix__zz_ramp (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_rdivide" c_casadi__IMatrix__zz_rdivide - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_rdivide - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_rdivide x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_rdivide errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_rdivide :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_rdivide x = casadi__IMatrix__zz_rdivide (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_rectangle" c_casadi__IMatrix__zz_rectangle - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_rectangle - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_rectangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_rectangle errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_rectangle :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_rectangle x = casadi__IMatrix__zz_rectangle (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_repmat__0" c_casadi__IMatrix__zz_repmat__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_repmat__0 - :: IMatrix -> Int -> IO IMatrix -casadi__IMatrix__zz_repmat__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_repmat__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_repmat__0 :: IMatrixClass a => a -> Int -> IO IMatrix -imatrix_zz_repmat__0 x = casadi__IMatrix__zz_repmat__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_repmat__1" c_casadi__IMatrix__zz_repmat__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_repmat__1 - :: IMatrix -> Int -> Int -> IO IMatrix -casadi__IMatrix__zz_repmat__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_repmat__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_repmat__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix -imatrix_zz_repmat__1 x = casadi__IMatrix__zz_repmat__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_reshape__0" c_casadi__IMatrix__zz_reshape__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_reshape__0 - :: IMatrix -> Sparsity -> IO IMatrix -casadi__IMatrix__zz_reshape__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_reshape__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_reshape__0 :: IMatrixClass a => a -> Sparsity -> IO IMatrix -imatrix_zz_reshape__0 x = casadi__IMatrix__zz_reshape__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_reshape__1" c_casadi__IMatrix__zz_reshape__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_reshape__1 - :: IMatrix -> Int -> Int -> IO IMatrix -casadi__IMatrix__zz_reshape__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_reshape__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_reshape__1 :: IMatrixClass a => a -> Int -> Int -> IO IMatrix -imatrix_zz_reshape__1 x = casadi__IMatrix__zz_reshape__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sign" c_casadi__IMatrix__zz_sign - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sign - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sign x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sign errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sign :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sign x = casadi__IMatrix__zz_sign (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_simplify" c_casadi__IMatrix__zz_simplify - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_simplify - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_simplify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_simplify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_simplify :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_simplify x = casadi__IMatrix__zz_simplify (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sin" c_casadi__IMatrix__zz_sin - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sin - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sin :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sin x = casadi__IMatrix__zz_sin (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sinh" c_casadi__IMatrix__zz_sinh - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sinh - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sinh :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sinh x = casadi__IMatrix__zz_sinh (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_solve" c_casadi__IMatrix__zz_solve - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_solve - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_solve x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_solve errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_solve :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_solve x = casadi__IMatrix__zz_solve (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sparsify__0" c_casadi__IMatrix__zz_sparsify__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sparsify__0 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sparsify__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sparsify__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sparsify__0 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sparsify__0 x = casadi__IMatrix__zz_sparsify__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sparsify__1" c_casadi__IMatrix__zz_sparsify__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sparsify__1 - :: IMatrix -> Double -> IO IMatrix -casadi__IMatrix__zz_sparsify__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sparsify__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sparsify__1 :: IMatrixClass a => a -> Double -> IO IMatrix -imatrix_zz_sparsify__1 x = casadi__IMatrix__zz_sparsify__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sprank" c_casadi__IMatrix__zz_sprank - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt -casadi__IMatrix__zz_sprank - :: IMatrix -> IO Int -casadi__IMatrix__zz_sprank x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sprank errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sprank :: IMatrixClass a => a -> IO Int -imatrix_zz_sprank x = casadi__IMatrix__zz_sprank (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_spy" c_casadi__IMatrix__zz_spy - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_spy - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_spy x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_spy errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_spy :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_spy x = casadi__IMatrix__zz_spy (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sqrt" c_casadi__IMatrix__zz_sqrt - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sqrt - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sqrt x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sqrt errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sqrt :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sqrt x = casadi__IMatrix__zz_sqrt (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_substitute__0" c_casadi__IMatrix__zz_substitute__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__zz_substitute__0 - :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO (Vector IMatrix) -casadi__IMatrix__zz_substitute__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_substitute__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_substitute__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO (Vector IMatrix) -imatrix_zz_substitute__0 = casadi__IMatrix__zz_substitute__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_substitute__1" c_casadi__IMatrix__zz_substitute__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_substitute__1 - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_substitute__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_substitute__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_substitute__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_substitute__1 x = casadi__IMatrix__zz_substitute__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_substituteInPlace__0" c_casadi__IMatrix__zz_substituteInPlace__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO () -casadi__IMatrix__zz_substituteInPlace__0 - :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () -casadi__IMatrix__zz_substituteInPlace__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_substituteInPlace__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_substituteInPlace__0 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () -imatrix_zz_substituteInPlace__0 = casadi__IMatrix__zz_substituteInPlace__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_substituteInPlace__1" c_casadi__IMatrix__zz_substituteInPlace__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> CInt -> IO () -casadi__IMatrix__zz_substituteInPlace__1 - :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Bool -> IO () -casadi__IMatrix__zz_substituteInPlace__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_substituteInPlace__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_substituteInPlace__1 :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Bool -> IO () -imatrix_zz_substituteInPlace__1 = casadi__IMatrix__zz_substituteInPlace__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sumAll" c_casadi__IMatrix__zz_sumAll - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sumAll - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sumAll x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sumAll errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sumAll :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sumAll x = casadi__IMatrix__zz_sumAll (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sumCols" c_casadi__IMatrix__zz_sumCols - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sumCols - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sumCols x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sumCols errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sumCols :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sumCols x = casadi__IMatrix__zz_sumCols (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sumRows" c_casadi__IMatrix__zz_sumRows - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sumRows - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sumRows x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sumRows errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sumRows :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sumRows x = casadi__IMatrix__zz_sumRows (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_sum_square" c_casadi__IMatrix__zz_sum_square - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_sum_square - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_sum_square x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_sum_square errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_sum_square :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_sum_square x = casadi__IMatrix__zz_sum_square (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_tan" c_casadi__IMatrix__zz_tan - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_tan - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_tan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_tan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_tan :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_tan x = casadi__IMatrix__zz_tan (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_tangent" c_casadi__IMatrix__zz_tangent - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_tangent - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_tangent x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_tangent errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_tangent :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_tangent x = casadi__IMatrix__zz_tangent (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_tanh" c_casadi__IMatrix__zz_tanh - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_tanh - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_tanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_tanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_tanh :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_tanh x = casadi__IMatrix__zz_tanh (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_taylor__0" c_casadi__IMatrix__zz_taylor__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_taylor__0 - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_taylor__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_taylor__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_taylor__0 :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_taylor__0 x = casadi__IMatrix__zz_taylor__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_taylor__1" c_casadi__IMatrix__zz_taylor__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_taylor__1 - :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_taylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_taylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_taylor__1 :: IMatrixClass a => a -> IMatrix -> IMatrix -> IO IMatrix -imatrix_zz_taylor__1 x = casadi__IMatrix__zz_taylor__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_taylor__2" c_casadi__IMatrix__zz_taylor__2 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_taylor__2 - :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix -casadi__IMatrix__zz_taylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_taylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_taylor__2 :: IMatrixClass a => a -> IMatrix -> IMatrix -> Int -> IO IMatrix -imatrix_zz_taylor__2 x = casadi__IMatrix__zz_taylor__2 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_times" c_casadi__IMatrix__zz_times - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_times - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_times x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_times errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_times :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_times x = casadi__IMatrix__zz_times (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_trace" c_casadi__IMatrix__zz_trace - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_trace - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_trace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_trace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_trace :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_trace x = casadi__IMatrix__zz_trace (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_triangle" c_casadi__IMatrix__zz_triangle - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_triangle - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_triangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_triangle errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_triangle :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_triangle x = casadi__IMatrix__zz_triangle (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_tril__0" c_casadi__IMatrix__zz_tril__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_tril__0 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_tril__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_tril__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_tril__0 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_tril__0 x = casadi__IMatrix__zz_tril__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_tril__1" c_casadi__IMatrix__zz_tril__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_tril__1 - :: IMatrix -> Bool -> IO IMatrix -casadi__IMatrix__zz_tril__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_tril__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_tril__1 :: IMatrixClass a => a -> Bool -> IO IMatrix -imatrix_zz_tril__1 x = casadi__IMatrix__zz_tril__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_tril2symm" c_casadi__IMatrix__zz_tril2symm - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_tril2symm - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_tril2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_tril2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_tril2symm :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_tril2symm x = casadi__IMatrix__zz_tril2symm (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_triu__0" c_casadi__IMatrix__zz_triu__0 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_triu__0 - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_triu__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_triu__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_triu__0 :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_triu__0 x = casadi__IMatrix__zz_triu__0 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_triu__1" c_casadi__IMatrix__zz_triu__1 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') -casadi__IMatrix__zz_triu__1 - :: IMatrix -> Bool -> IO IMatrix -casadi__IMatrix__zz_triu__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_triu__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_triu__1 :: IMatrixClass a => a -> Bool -> IO IMatrix -imatrix_zz_triu__1 x = casadi__IMatrix__zz_triu__1 (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_triu2symm" c_casadi__IMatrix__zz_triu2symm - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_triu2symm - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_triu2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_triu2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_triu2symm :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_triu2symm x = casadi__IMatrix__zz_triu2symm (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_unite" c_casadi__IMatrix__zz_unite - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_unite - :: IMatrix -> IMatrix -> IO IMatrix -casadi__IMatrix__zz_unite x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_unite errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_unite :: IMatrixClass a => a -> IMatrix -> IO IMatrix -imatrix_zz_unite x = casadi__IMatrix__zz_unite (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_vec" c_casadi__IMatrix__zz_vec - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_vec - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_vec x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_vec errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_vec :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_vec x = casadi__IMatrix__zz_vec (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_vecNZ" c_casadi__IMatrix__zz_vecNZ - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -casadi__IMatrix__zz_vecNZ - :: IMatrix -> IO IMatrix -casadi__IMatrix__zz_vecNZ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_vecNZ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_vecNZ :: IMatrixClass a => a -> IO IMatrix -imatrix_zz_vecNZ x = casadi__IMatrix__zz_vecNZ (castIMatrix x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_vecNZcat" c_casadi__IMatrix__zz_vecNZcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') -casadi__IMatrix__zz_vecNZcat - :: Vector IMatrix -> IO IMatrix -casadi__IMatrix__zz_vecNZcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_vecNZcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_vecNZcat :: Vector IMatrix -> IO IMatrix -imatrix_zz_vecNZcat = casadi__IMatrix__zz_vecNZcat - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_veccat" c_casadi__IMatrix__zz_veccat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') -casadi__IMatrix__zz_veccat - :: Vector IMatrix -> IO IMatrix -casadi__IMatrix__zz_veccat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_veccat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_veccat :: Vector IMatrix -> IO IMatrix -imatrix_zz_veccat = casadi__IMatrix__zz_veccat - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_vertcat" c_casadi__IMatrix__zz_vertcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') -casadi__IMatrix__zz_vertcat - :: Vector IMatrix -> IO IMatrix -casadi__IMatrix__zz_vertcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_vertcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_vertcat :: Vector IMatrix -> IO IMatrix -imatrix_zz_vertcat = casadi__IMatrix__zz_vertcat - - --- direct wrapper -foreign import ccall unsafe "casadi__IMatrix__zz_vertsplit" c_casadi__IMatrix__zz_vertsplit - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) -casadi__IMatrix__zz_vertsplit - :: IMatrix -> Vector Int -> IO (Vector IMatrix) -casadi__IMatrix__zz_vertsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IMatrix__zz_vertsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -imatrix_zz_vertsplit :: IMatrixClass a => a -> Vector Int -> IO (Vector IMatrix) -imatrix_zz_vertsplit x = casadi__IMatrix__zz_vertsplit (castIMatrix x) + imatrix___nonzero__, + imatrix_append, + imatrix_appendColumns, + imatrix_binary, + imatrix_className, + imatrix_clear, + imatrix_colind, + imatrix_dimString, + imatrix_enlarge__0, + imatrix_enlarge__1, + imatrix_erase__0, + imatrix_erase__1, + imatrix_erase__2, + imatrix_erase__3, + imatrix_eye, + imatrix_find__0, + imatrix_find__1, + imatrix_getColind, + imatrix_getDep__0, + imatrix_getDep__1, + imatrix_getDescription, + imatrix_getElementHash, + imatrix_getEqualityCheckingDepth, + imatrix_getIntValue, + imatrix_getNZ__0, + imatrix_getNZ__1, + imatrix_getNZ__2, + imatrix_getName, + imatrix_getNdeps, + imatrix_getRepresentation, + imatrix_getRow, + imatrix_getSparsity, + imatrix_getSym, + imatrix_getValue__0, + imatrix_getValue__1, + imatrix_get__0, + imatrix_get__1, + imatrix_get__2, + imatrix_get__3, + imatrix_get__4, + imatrix_get__5, + imatrix_get__6, + imatrix_get__7, + imatrix_hasDuplicates, + imatrix_hasNZ, + imatrix_hasNonStructuralZeros, + imatrix_inf__0, + imatrix_inf__1, + imatrix_inf__2, + imatrix_inf__3, + imatrix_inf__4, + imatrix_isCommutative, + imatrix_isConstant, + imatrix_isIdentity, + imatrix_isInteger, + imatrix_isLeaf, + imatrix_isMinusOne, + imatrix_isOne, + imatrix_isRegular, + imatrix_isSlice__0, + imatrix_isSlice__1, + imatrix_isSmooth, + imatrix_isSymbolic, + imatrix_isValidInput, + imatrix_isZero, + imatrix_iscolumn, + imatrix_isdense, + imatrix_isempty__0, + imatrix_isempty__1, + imatrix_isrow, + imatrix_isscalar__0, + imatrix_isscalar__1, + imatrix_issquare, + imatrix_istril, + imatrix_istriu, + imatrix_isvector, + imatrix_makeSparse__0, + imatrix_makeSparse__1, + imatrix_matrix_matrix, + imatrix_matrix_scalar, + imatrix_nan__0, + imatrix_nan__1, + imatrix_nan__2, + imatrix_nan__3, + imatrix_nan__4, + imatrix_nnz, + imatrix_nonzeros, + imatrix_nonzeros_int, + imatrix_numel__0, + imatrix_numel__1, + imatrix_ones__0, + imatrix_ones__1, + imatrix_ones__2, + imatrix_ones__3, + imatrix_ones__4, + imatrix_operator_minus, + imatrix_operator_plus, + imatrix_printDense, + imatrix_printScalar, + imatrix_printSparse, + imatrix_printSplit, + imatrix_printVector, + imatrix_printme, + imatrix_remove, + imatrix_reserve__0, + imatrix_reserve__1, + imatrix_resetInput, + imatrix_resize, + imatrix_row, + imatrix_sanityCheck__0, + imatrix_sanityCheck__1, + imatrix_scalar_matrix, + imatrix_setEqualityCheckingDepth__0, + imatrix_setEqualityCheckingDepth__1, + imatrix_setNZ__0, + imatrix_setNZ__1, + imatrix_setNZ__2, + imatrix_setNZ__3, + imatrix_setPrecision, + imatrix_setScientific, + imatrix_setSym, + imatrix_setValue__0, + imatrix_setValue__1, + imatrix_setWidth, + imatrix_setZero, + imatrix_set__0, + imatrix_set__1, + imatrix_set__10, + imatrix_set__2, + imatrix_set__3, + imatrix_set__4, + imatrix_set__5, + imatrix_set__6, + imatrix_set__7, + imatrix_set__8, + imatrix_set__9, + imatrix_shape__0, + imatrix_shape__1, + imatrix_size, + imatrix_size1, + imatrix_size2, + imatrix_sizeD, + imatrix_sizeL, + imatrix_sizeU, + imatrix_sparse__0, + imatrix_sparse__1, + imatrix_sparse__2, + imatrix_sparse__3, + imatrix_sparse__4, + imatrix_sparsity, + imatrix_sym__0, + imatrix_sym__1, + imatrix_sym__2, + imatrix_sym__3, + imatrix_sym__4, + imatrix_sym__5, + imatrix_sym__6, + imatrix_sym__7, + imatrix_sym__8, + imatrix_toSlice__0, + imatrix_toSlice__1, + imatrix_triplet__0, + imatrix_triplet__1, + imatrix_triplet__2, + imatrix_unary, + imatrix_zeros__0, + imatrix_zeros__1, + imatrix_zeros__2, + imatrix_zeros__3, + imatrix_zeros__4, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__0" c_casadi__IMatrix__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr IMatrix') +casadi__IMatrix__CONSTRUCTOR__0 + :: Vector (Vector Double) -> IO IMatrix +casadi__IMatrix__CONSTRUCTOR__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__CONSTRUCTOR__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix__0 :: Vector (Vector Double) -> IO IMatrix +imatrix__0 = casadi__IMatrix__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__1" c_casadi__IMatrix__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr IMatrix') +casadi__IMatrix__CONSTRUCTOR__1 + :: Double -> IO IMatrix +casadi__IMatrix__CONSTRUCTOR__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__CONSTRUCTOR__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix__1 :: Double -> IO IMatrix +imatrix__1 = casadi__IMatrix__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__2" c_casadi__IMatrix__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__CONSTRUCTOR__2 + :: Sparsity -> IMatrix -> IO IMatrix +casadi__IMatrix__CONSTRUCTOR__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__CONSTRUCTOR__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix__2 :: Sparsity -> IMatrix -> IO IMatrix +imatrix__2 = casadi__IMatrix__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__3" c_casadi__IMatrix__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi__IMatrix__CONSTRUCTOR__3 + :: Sparsity -> IO IMatrix +casadi__IMatrix__CONSTRUCTOR__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__CONSTRUCTOR__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix__3 :: Sparsity -> IO IMatrix +imatrix__3 = casadi__IMatrix__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__4" c_casadi__IMatrix__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__CONSTRUCTOR__4 + :: Int -> Int -> IO IMatrix +casadi__IMatrix__CONSTRUCTOR__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__CONSTRUCTOR__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix__4 :: Int -> Int -> IO IMatrix +imatrix__4 = casadi__IMatrix__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__5" c_casadi__IMatrix__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__CONSTRUCTOR__5 + :: IMatrix -> IO IMatrix +casadi__IMatrix__CONSTRUCTOR__5 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__CONSTRUCTOR__5 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix__5 :: IMatrix -> IO IMatrix +imatrix__5 = casadi__IMatrix__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__6" c_casadi__IMatrix__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') +casadi__IMatrix__CONSTRUCTOR__6 + :: IO IMatrix +casadi__IMatrix__CONSTRUCTOR__6 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__CONSTRUCTOR__6 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix__6 :: IO IMatrix +imatrix__6 = casadi__IMatrix__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__T" c_casadi__IMatrix__T + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__T + :: IMatrix -> IO IMatrix +casadi__IMatrix__T x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__T errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_T :: IMatrixClass a => a -> IO IMatrix +imatrix_T x = casadi__IMatrix__T (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix____nonzero__" c_casadi__IMatrix____nonzero__ + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix____nonzero__ + :: IMatrix -> IO Bool +casadi__IMatrix____nonzero__ x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix____nonzero__ errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix___nonzero__ :: IMatrixClass a => a -> IO Bool +imatrix___nonzero__ x = casadi__IMatrix____nonzero__ (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__append" c_casadi__IMatrix__append + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__IMatrix__append + :: IMatrix -> IMatrix -> IO () +casadi__IMatrix__append x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__append errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_append :: IMatrixClass a => a -> IMatrix -> IO () +imatrix_append x = casadi__IMatrix__append (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__appendColumns" c_casadi__IMatrix__appendColumns + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__IMatrix__appendColumns + :: IMatrix -> IMatrix -> IO () +casadi__IMatrix__appendColumns x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__appendColumns errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_appendColumns :: IMatrixClass a => a -> IMatrix -> IO () +imatrix_appendColumns x = casadi__IMatrix__appendColumns (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__binary" c_casadi__IMatrix__binary + :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__binary + :: Int -> IMatrix -> IMatrix -> IO IMatrix +casadi__IMatrix__binary x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__binary errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_binary :: Int -> IMatrix -> IMatrix -> IO IMatrix +imatrix_binary = casadi__IMatrix__binary + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__className" c_casadi__IMatrix__className + :: Ptr (Ptr StdString) -> IO (Ptr StdString) +casadi__IMatrix__className + :: IO String +casadi__IMatrix__className = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__className errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_className :: IO String +imatrix_className = casadi__IMatrix__className + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__clear" c_casadi__IMatrix__clear + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__clear + :: IMatrix -> IO () +casadi__IMatrix__clear x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__clear errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_clear :: IMatrixClass a => a -> IO () +imatrix_clear x = casadi__IMatrix__clear (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__colind" c_casadi__IMatrix__colind + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt +casadi__IMatrix__colind + :: IMatrix -> Int -> IO Int +casadi__IMatrix__colind x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__colind errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_colind :: IMatrixClass a => a -> Int -> IO Int +imatrix_colind x = casadi__IMatrix__colind (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__dimString" c_casadi__IMatrix__dimString + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) +casadi__IMatrix__dimString + :: IMatrix -> IO String +casadi__IMatrix__dimString x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__dimString errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_dimString :: IMatrixClass a => a -> IO String +imatrix_dimString x = casadi__IMatrix__dimString (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__enlarge__0" c_casadi__IMatrix__enlarge__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__IMatrix__enlarge__0 + :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> IO () +casadi__IMatrix__enlarge__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_enlarge__0 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () +imatrix_enlarge__0 x = casadi__IMatrix__enlarge__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__enlarge__1" c_casadi__IMatrix__enlarge__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__IMatrix__enlarge__1 + :: IMatrix -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +casadi__IMatrix__enlarge__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_enlarge__1 :: IMatrixClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +imatrix_enlarge__1 x = casadi__IMatrix__enlarge__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__erase__0" c_casadi__IMatrix__erase__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO () +casadi__IMatrix__erase__0 + :: IMatrix -> Vector Int -> IO () +casadi__IMatrix__erase__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__erase__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_erase__0 :: IMatrixClass a => a -> Vector Int -> IO () +imatrix_erase__0 x = casadi__IMatrix__erase__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__erase__1" c_casadi__IMatrix__erase__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__IMatrix__erase__1 + :: IMatrix -> Vector Int -> Bool -> IO () +casadi__IMatrix__erase__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__erase__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_erase__1 :: IMatrixClass a => a -> Vector Int -> Bool -> IO () +imatrix_erase__1 x = casadi__IMatrix__erase__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__erase__2" c_casadi__IMatrix__erase__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__IMatrix__erase__2 + :: IMatrix -> Vector Int -> Vector Int -> IO () +casadi__IMatrix__erase__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__erase__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_erase__2 :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () +imatrix_erase__2 x = casadi__IMatrix__erase__2 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__erase__3" c_casadi__IMatrix__erase__3 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__IMatrix__erase__3 + :: IMatrix -> Vector Int -> Vector Int -> Bool -> IO () +casadi__IMatrix__erase__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__erase__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_erase__3 :: IMatrixClass a => a -> Vector Int -> Vector Int -> Bool -> IO () +imatrix_erase__3 x = casadi__IMatrix__erase__3 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__eye" c_casadi__IMatrix__eye + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__eye + :: Int -> IO IMatrix +casadi__IMatrix__eye x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__eye errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_eye :: Int -> IO IMatrix +imatrix_eye = casadi__IMatrix__eye + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__find__0" c_casadi__IMatrix__find__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) +casadi__IMatrix__find__0 + :: IMatrix -> IO (Vector Int) +casadi__IMatrix__find__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__find__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_find__0 :: IMatrixClass a => a -> IO (Vector Int) +imatrix_find__0 x = casadi__IMatrix__find__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__find__1" c_casadi__IMatrix__find__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec CInt)) +casadi__IMatrix__find__1 + :: IMatrix -> Bool -> IO (Vector Int) +casadi__IMatrix__find__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__find__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_find__1 :: IMatrixClass a => a -> Bool -> IO (Vector Int) +imatrix_find__1 x = casadi__IMatrix__find__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__0" c_casadi__IMatrix__get__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__IMatrix__get__0 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () +casadi__IMatrix__get__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () +imatrix_get__0 x = casadi__IMatrix__get__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__1" c_casadi__IMatrix__get__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__IMatrix__get__1 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO () +casadi__IMatrix__get__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> IO () +imatrix_get__1 x = casadi__IMatrix__get__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__2" c_casadi__IMatrix__get__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__IMatrix__get__2 + :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO () +casadi__IMatrix__get__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> IO () +imatrix_get__2 x = casadi__IMatrix__get__2 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__3" c_casadi__IMatrix__get__3 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__IMatrix__get__3 + :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO () +casadi__IMatrix__get__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> IO () +imatrix_get__3 x = casadi__IMatrix__get__3 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__4" c_casadi__IMatrix__get__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO () +casadi__IMatrix__get__4 + :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO () +casadi__IMatrix__get__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> IO () +imatrix_get__4 x = casadi__IMatrix__get__4 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__5" c_casadi__IMatrix__get__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__IMatrix__get__5 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () +casadi__IMatrix__get__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () +imatrix_get__5 x = casadi__IMatrix__get__5 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__6" c_casadi__IMatrix__get__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__IMatrix__get__6 + :: IMatrix -> IMatrix -> Bool -> Slice -> IO () +casadi__IMatrix__get__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () +imatrix_get__6 x = casadi__IMatrix__get__6 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__get__7" c_casadi__IMatrix__get__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__IMatrix__get__7 + :: IMatrix -> Vector Double -> IO () +casadi__IMatrix__get__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__get__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_get__7 :: IMatrixClass a => a -> Vector Double -> IO () +imatrix_get__7 x = casadi__IMatrix__get__7 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getColind" c_casadi__IMatrix__getColind + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) +casadi__IMatrix__getColind + :: IMatrix -> IO (Vector Int) +casadi__IMatrix__getColind x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getColind errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getColind :: IMatrixClass a => a -> IO (Vector Int) +imatrix_getColind x = casadi__IMatrix__getColind (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getDep__0" c_casadi__IMatrix__getDep__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__getDep__0 + :: IMatrix -> IO IMatrix +casadi__IMatrix__getDep__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getDep__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getDep__0 :: IMatrixClass a => a -> IO IMatrix +imatrix_getDep__0 x = casadi__IMatrix__getDep__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getDep__1" c_casadi__IMatrix__getDep__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__getDep__1 + :: IMatrix -> Int -> IO IMatrix +casadi__IMatrix__getDep__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getDep__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getDep__1 :: IMatrixClass a => a -> Int -> IO IMatrix +imatrix_getDep__1 x = casadi__IMatrix__getDep__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getElementHash" c_casadi__IMatrix__getElementHash + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CSize +casadi__IMatrix__getElementHash + :: IMatrix -> IO CSize +casadi__IMatrix__getElementHash x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getElementHash errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getElementHash :: IMatrixClass a => a -> IO CSize +imatrix_getElementHash x = casadi__IMatrix__getElementHash (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getEqualityCheckingDepth" c_casadi__IMatrix__getEqualityCheckingDepth + :: Ptr (Ptr StdString) -> IO CInt +casadi__IMatrix__getEqualityCheckingDepth + :: IO Int +casadi__IMatrix__getEqualityCheckingDepth = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getEqualityCheckingDepth errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getEqualityCheckingDepth :: IO Int +imatrix_getEqualityCheckingDepth = casadi__IMatrix__getEqualityCheckingDepth + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getIntValue" c_casadi__IMatrix__getIntValue + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__getIntValue + :: IMatrix -> IO Int +casadi__IMatrix__getIntValue x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getIntValue errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getIntValue :: IMatrixClass a => a -> IO Int +imatrix_getIntValue x = casadi__IMatrix__getIntValue (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getNZ__0" c_casadi__IMatrix__getNZ__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__IMatrix__getNZ__0 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () +casadi__IMatrix__getNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () +imatrix_getNZ__0 x = casadi__IMatrix__getNZ__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getNZ__1" c_casadi__IMatrix__getNZ__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__IMatrix__getNZ__1 + :: IMatrix -> IMatrix -> Bool -> Slice -> IO () +casadi__IMatrix__getNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () +imatrix_getNZ__1 x = casadi__IMatrix__getNZ__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getNZ__2" c_casadi__IMatrix__getNZ__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__IMatrix__getNZ__2 + :: IMatrix -> Vector Double -> IO () +casadi__IMatrix__getNZ__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getNZ__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getNZ__2 :: IMatrixClass a => a -> Vector Double -> IO () +imatrix_getNZ__2 x = casadi__IMatrix__getNZ__2 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getName" c_casadi__IMatrix__getName + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr StdString) +casadi__IMatrix__getName + :: IMatrix -> IO String +casadi__IMatrix__getName x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getName errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getName :: IMatrixClass a => a -> IO String +imatrix_getName x = casadi__IMatrix__getName (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getNdeps" c_casadi__IMatrix__getNdeps + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__getNdeps + :: IMatrix -> IO Int +casadi__IMatrix__getNdeps x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getNdeps errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getNdeps :: IMatrixClass a => a -> IO Int +imatrix_getNdeps x = casadi__IMatrix__getNdeps (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getRow" c_casadi__IMatrix__getRow + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) +casadi__IMatrix__getRow + :: IMatrix -> IO (Vector Int) +casadi__IMatrix__getRow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getRow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getRow :: IMatrixClass a => a -> IO (Vector Int) +imatrix_getRow x = casadi__IMatrix__getRow (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getSparsity" c_casadi__IMatrix__getSparsity + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') +casadi__IMatrix__getSparsity + :: IMatrix -> IO Sparsity +casadi__IMatrix__getSparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getSparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getSparsity :: IMatrixClass a => a -> IO Sparsity +imatrix_getSparsity x = casadi__IMatrix__getSparsity (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getSym" c_casadi__IMatrix__getSym + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__IMatrix__getSym + :: IMatrix -> Vector Double -> IO () +casadi__IMatrix__getSym x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getSym errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getSym :: IMatrixClass a => a -> Vector Double -> IO () +imatrix_getSym x = casadi__IMatrix__getSym (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getValue__0" c_casadi__IMatrix__getValue__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CDouble +casadi__IMatrix__getValue__0 + :: IMatrix -> Int -> IO Double +casadi__IMatrix__getValue__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getValue__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getValue__0 :: IMatrixClass a => a -> Int -> IO Double +imatrix_getValue__0 x = casadi__IMatrix__getValue__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__getValue__1" c_casadi__IMatrix__getValue__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CDouble +casadi__IMatrix__getValue__1 + :: IMatrix -> IO Double +casadi__IMatrix__getValue__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__getValue__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_getValue__1 :: IMatrixClass a => a -> IO Double +imatrix_getValue__1 x = casadi__IMatrix__getValue__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__hasDuplicates" c_casadi__IMatrix__hasDuplicates + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__hasDuplicates + :: IMatrix -> IO Bool +casadi__IMatrix__hasDuplicates x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__hasDuplicates errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_hasDuplicates :: IMatrixClass a => a -> IO Bool +imatrix_hasDuplicates x = casadi__IMatrix__hasDuplicates (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__hasNZ" c_casadi__IMatrix__hasNZ + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt +casadi__IMatrix__hasNZ + :: IMatrix -> Int -> Int -> IO Bool +casadi__IMatrix__hasNZ x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__hasNZ errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_hasNZ :: IMatrixClass a => a -> Int -> Int -> IO Bool +imatrix_hasNZ x = casadi__IMatrix__hasNZ (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__hasNonStructuralZeros" c_casadi__IMatrix__hasNonStructuralZeros + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__hasNonStructuralZeros + :: IMatrix -> IO Bool +casadi__IMatrix__hasNonStructuralZeros x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__hasNonStructuralZeros errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_hasNonStructuralZeros :: IMatrixClass a => a -> IO Bool +imatrix_hasNonStructuralZeros x = casadi__IMatrix__hasNonStructuralZeros (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__inf__0" c_casadi__IMatrix__inf__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi__IMatrix__inf__0 + :: (Int, Int) -> IO IMatrix +casadi__IMatrix__inf__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__inf__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_inf__0 :: (Int, Int) -> IO IMatrix +imatrix_inf__0 = casadi__IMatrix__inf__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__inf__1" c_casadi__IMatrix__inf__1 + :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') +casadi__IMatrix__inf__1 + :: IO IMatrix +casadi__IMatrix__inf__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__inf__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_inf__1 :: IO IMatrix +imatrix_inf__1 = casadi__IMatrix__inf__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__inf__2" c_casadi__IMatrix__inf__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__inf__2 + :: Int -> IO IMatrix +casadi__IMatrix__inf__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__inf__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_inf__2 :: Int -> IO IMatrix +imatrix_inf__2 = casadi__IMatrix__inf__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__inf__3" c_casadi__IMatrix__inf__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__inf__3 + :: Int -> Int -> IO IMatrix +casadi__IMatrix__inf__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__inf__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_inf__3 :: Int -> Int -> IO IMatrix +imatrix_inf__3 = casadi__IMatrix__inf__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__inf__4" c_casadi__IMatrix__inf__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi__IMatrix__inf__4 + :: Sparsity -> IO IMatrix +casadi__IMatrix__inf__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__inf__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_inf__4 :: Sparsity -> IO IMatrix +imatrix_inf__4 = casadi__IMatrix__inf__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isCommutative" c_casadi__IMatrix__isCommutative + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isCommutative + :: IMatrix -> IO Bool +casadi__IMatrix__isCommutative x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isCommutative errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isCommutative :: IMatrixClass a => a -> IO Bool +imatrix_isCommutative x = casadi__IMatrix__isCommutative (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isConstant" c_casadi__IMatrix__isConstant + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isConstant + :: IMatrix -> IO Bool +casadi__IMatrix__isConstant x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isConstant errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isConstant :: IMatrixClass a => a -> IO Bool +imatrix_isConstant x = casadi__IMatrix__isConstant (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isIdentity" c_casadi__IMatrix__isIdentity + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isIdentity + :: IMatrix -> IO Bool +casadi__IMatrix__isIdentity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isIdentity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isIdentity :: IMatrixClass a => a -> IO Bool +imatrix_isIdentity x = casadi__IMatrix__isIdentity (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isInteger" c_casadi__IMatrix__isInteger + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isInteger + :: IMatrix -> IO Bool +casadi__IMatrix__isInteger x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isInteger errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isInteger :: IMatrixClass a => a -> IO Bool +imatrix_isInteger x = casadi__IMatrix__isInteger (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isLeaf" c_casadi__IMatrix__isLeaf + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isLeaf + :: IMatrix -> IO Bool +casadi__IMatrix__isLeaf x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isLeaf errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isLeaf :: IMatrixClass a => a -> IO Bool +imatrix_isLeaf x = casadi__IMatrix__isLeaf (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isMinusOne" c_casadi__IMatrix__isMinusOne + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isMinusOne + :: IMatrix -> IO Bool +casadi__IMatrix__isMinusOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isMinusOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isMinusOne :: IMatrixClass a => a -> IO Bool +imatrix_isMinusOne x = casadi__IMatrix__isMinusOne (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isOne" c_casadi__IMatrix__isOne + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isOne + :: IMatrix -> IO Bool +casadi__IMatrix__isOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isOne :: IMatrixClass a => a -> IO Bool +imatrix_isOne x = casadi__IMatrix__isOne (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isRegular" c_casadi__IMatrix__isRegular + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isRegular + :: IMatrix -> IO Bool +casadi__IMatrix__isRegular x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isRegular errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isRegular :: IMatrixClass a => a -> IO Bool +imatrix_isRegular x = casadi__IMatrix__isRegular (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isSlice__0" c_casadi__IMatrix__isSlice__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isSlice__0 + :: IMatrix -> IO Bool +casadi__IMatrix__isSlice__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isSlice__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isSlice__0 :: IMatrixClass a => a -> IO Bool +imatrix_isSlice__0 x = casadi__IMatrix__isSlice__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isSlice__1" c_casadi__IMatrix__isSlice__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt +casadi__IMatrix__isSlice__1 + :: IMatrix -> Bool -> IO Bool +casadi__IMatrix__isSlice__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isSlice__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isSlice__1 :: IMatrixClass a => a -> Bool -> IO Bool +imatrix_isSlice__1 x = casadi__IMatrix__isSlice__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isSmooth" c_casadi__IMatrix__isSmooth + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isSmooth + :: IMatrix -> IO Bool +casadi__IMatrix__isSmooth x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isSmooth errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isSmooth :: IMatrixClass a => a -> IO Bool +imatrix_isSmooth x = casadi__IMatrix__isSmooth (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isSymbolic" c_casadi__IMatrix__isSymbolic + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isSymbolic + :: IMatrix -> IO Bool +casadi__IMatrix__isSymbolic x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isSymbolic errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isSymbolic :: IMatrixClass a => a -> IO Bool +imatrix_isSymbolic x = casadi__IMatrix__isSymbolic (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isValidInput" c_casadi__IMatrix__isValidInput + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isValidInput + :: IMatrix -> IO Bool +casadi__IMatrix__isValidInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isValidInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isValidInput :: IMatrixClass a => a -> IO Bool +imatrix_isValidInput x = casadi__IMatrix__isValidInput (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isZero" c_casadi__IMatrix__isZero + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isZero + :: IMatrix -> IO Bool +casadi__IMatrix__isZero x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isZero errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isZero :: IMatrixClass a => a -> IO Bool +imatrix_isZero x = casadi__IMatrix__isZero (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__iscolumn" c_casadi__IMatrix__iscolumn + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__iscolumn + :: IMatrix -> IO Bool +casadi__IMatrix__iscolumn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__iscolumn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_iscolumn :: IMatrixClass a => a -> IO Bool +imatrix_iscolumn x = casadi__IMatrix__iscolumn (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isdense" c_casadi__IMatrix__isdense + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isdense + :: IMatrix -> IO Bool +casadi__IMatrix__isdense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isdense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isdense :: IMatrixClass a => a -> IO Bool +imatrix_isdense x = casadi__IMatrix__isdense (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isempty__0" c_casadi__IMatrix__isempty__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isempty__0 + :: IMatrix -> IO Bool +casadi__IMatrix__isempty__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isempty__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isempty__0 :: IMatrixClass a => a -> IO Bool +imatrix_isempty__0 x = casadi__IMatrix__isempty__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isempty__1" c_casadi__IMatrix__isempty__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt +casadi__IMatrix__isempty__1 + :: IMatrix -> Bool -> IO Bool +casadi__IMatrix__isempty__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isempty__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isempty__1 :: IMatrixClass a => a -> Bool -> IO Bool +imatrix_isempty__1 x = casadi__IMatrix__isempty__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isrow" c_casadi__IMatrix__isrow + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isrow + :: IMatrix -> IO Bool +casadi__IMatrix__isrow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isrow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isrow :: IMatrixClass a => a -> IO Bool +imatrix_isrow x = casadi__IMatrix__isrow (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isscalar__0" c_casadi__IMatrix__isscalar__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isscalar__0 + :: IMatrix -> IO Bool +casadi__IMatrix__isscalar__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isscalar__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isscalar__0 :: IMatrixClass a => a -> IO Bool +imatrix_isscalar__0 x = casadi__IMatrix__isscalar__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isscalar__1" c_casadi__IMatrix__isscalar__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt +casadi__IMatrix__isscalar__1 + :: IMatrix -> Bool -> IO Bool +casadi__IMatrix__isscalar__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isscalar__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isscalar__1 :: IMatrixClass a => a -> Bool -> IO Bool +imatrix_isscalar__1 x = casadi__IMatrix__isscalar__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__issquare" c_casadi__IMatrix__issquare + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__issquare + :: IMatrix -> IO Bool +casadi__IMatrix__issquare x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__issquare errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_issquare :: IMatrixClass a => a -> IO Bool +imatrix_issquare x = casadi__IMatrix__issquare (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__istril" c_casadi__IMatrix__istril + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__istril + :: IMatrix -> IO Bool +casadi__IMatrix__istril x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__istril errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_istril :: IMatrixClass a => a -> IO Bool +imatrix_istril x = casadi__IMatrix__istril (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__istriu" c_casadi__IMatrix__istriu + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__istriu + :: IMatrix -> IO Bool +casadi__IMatrix__istriu x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__istriu errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_istriu :: IMatrixClass a => a -> IO Bool +imatrix_istriu x = casadi__IMatrix__istriu (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__isvector" c_casadi__IMatrix__isvector + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__isvector + :: IMatrix -> IO Bool +casadi__IMatrix__isvector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__isvector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_isvector :: IMatrixClass a => a -> IO Bool +imatrix_isvector x = casadi__IMatrix__isvector (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__makeSparse__0" c_casadi__IMatrix__makeSparse__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__makeSparse__0 + :: IMatrix -> IO () +casadi__IMatrix__makeSparse__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__makeSparse__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_makeSparse__0 :: IMatrixClass a => a -> IO () +imatrix_makeSparse__0 x = casadi__IMatrix__makeSparse__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__makeSparse__1" c_casadi__IMatrix__makeSparse__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () +casadi__IMatrix__makeSparse__1 + :: IMatrix -> Double -> IO () +casadi__IMatrix__makeSparse__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__makeSparse__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_makeSparse__1 :: IMatrixClass a => a -> Double -> IO () +imatrix_makeSparse__1 x = casadi__IMatrix__makeSparse__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__matrix_matrix" c_casadi__IMatrix__matrix_matrix + :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__matrix_matrix + :: Int -> IMatrix -> IMatrix -> IO IMatrix +casadi__IMatrix__matrix_matrix x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__matrix_matrix errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_matrix_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix +imatrix_matrix_matrix = casadi__IMatrix__matrix_matrix + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__matrix_scalar" c_casadi__IMatrix__matrix_scalar + :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__matrix_scalar + :: Int -> IMatrix -> IMatrix -> IO IMatrix +casadi__IMatrix__matrix_scalar x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__matrix_scalar errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_matrix_scalar :: Int -> IMatrix -> IMatrix -> IO IMatrix +imatrix_matrix_scalar = casadi__IMatrix__matrix_scalar + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nan__0" c_casadi__IMatrix__nan__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi__IMatrix__nan__0 + :: (Int, Int) -> IO IMatrix +casadi__IMatrix__nan__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nan__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nan__0 :: (Int, Int) -> IO IMatrix +imatrix_nan__0 = casadi__IMatrix__nan__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nan__1" c_casadi__IMatrix__nan__1 + :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') +casadi__IMatrix__nan__1 + :: IO IMatrix +casadi__IMatrix__nan__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nan__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nan__1 :: IO IMatrix +imatrix_nan__1 = casadi__IMatrix__nan__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nan__2" c_casadi__IMatrix__nan__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__nan__2 + :: Int -> IO IMatrix +casadi__IMatrix__nan__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nan__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nan__2 :: Int -> IO IMatrix +imatrix_nan__2 = casadi__IMatrix__nan__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nan__3" c_casadi__IMatrix__nan__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__nan__3 + :: Int -> Int -> IO IMatrix +casadi__IMatrix__nan__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nan__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nan__3 :: Int -> Int -> IO IMatrix +imatrix_nan__3 = casadi__IMatrix__nan__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nan__4" c_casadi__IMatrix__nan__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi__IMatrix__nan__4 + :: Sparsity -> IO IMatrix +casadi__IMatrix__nan__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nan__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nan__4 :: Sparsity -> IO IMatrix +imatrix_nan__4 = casadi__IMatrix__nan__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nnz" c_casadi__IMatrix__nnz + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__nnz + :: IMatrix -> IO Int +casadi__IMatrix__nnz x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nnz errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nnz :: IMatrixClass a => a -> IO Int +imatrix_nnz x = casadi__IMatrix__nnz (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nonzeros" c_casadi__IMatrix__nonzeros + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CDouble)) +casadi__IMatrix__nonzeros + :: IMatrix -> IO (Vector Double) +casadi__IMatrix__nonzeros x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nonzeros errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nonzeros :: IMatrixClass a => a -> IO (Vector Double) +imatrix_nonzeros x = casadi__IMatrix__nonzeros (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__nonzeros_int" c_casadi__IMatrix__nonzeros_int + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec CInt)) +casadi__IMatrix__nonzeros_int + :: IMatrix -> IO (Vector Int) +casadi__IMatrix__nonzeros_int x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__nonzeros_int errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_nonzeros_int :: IMatrixClass a => a -> IO (Vector Int) +imatrix_nonzeros_int x = casadi__IMatrix__nonzeros_int (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__numel__0" c_casadi__IMatrix__numel__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt +casadi__IMatrix__numel__0 + :: IMatrix -> Int -> IO Int +casadi__IMatrix__numel__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__numel__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_numel__0 :: IMatrixClass a => a -> Int -> IO Int +imatrix_numel__0 x = casadi__IMatrix__numel__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__numel__1" c_casadi__IMatrix__numel__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__numel__1 + :: IMatrix -> IO Int +casadi__IMatrix__numel__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__numel__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_numel__1 :: IMatrixClass a => a -> IO Int +imatrix_numel__1 x = casadi__IMatrix__numel__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__ones__0" c_casadi__IMatrix__ones__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi__IMatrix__ones__0 + :: (Int, Int) -> IO IMatrix +casadi__IMatrix__ones__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__ones__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_ones__0 :: (Int, Int) -> IO IMatrix +imatrix_ones__0 = casadi__IMatrix__ones__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__ones__1" c_casadi__IMatrix__ones__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi__IMatrix__ones__1 + :: Sparsity -> IO IMatrix +casadi__IMatrix__ones__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__ones__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_ones__1 :: Sparsity -> IO IMatrix +imatrix_ones__1 = casadi__IMatrix__ones__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__ones__2" c_casadi__IMatrix__ones__2 + :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') +casadi__IMatrix__ones__2 + :: IO IMatrix +casadi__IMatrix__ones__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__ones__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_ones__2 :: IO IMatrix +imatrix_ones__2 = casadi__IMatrix__ones__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__ones__3" c_casadi__IMatrix__ones__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__ones__3 + :: Int -> IO IMatrix +casadi__IMatrix__ones__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__ones__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_ones__3 :: Int -> IO IMatrix +imatrix_ones__3 = casadi__IMatrix__ones__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__ones__4" c_casadi__IMatrix__ones__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__ones__4 + :: Int -> Int -> IO IMatrix +casadi__IMatrix__ones__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__ones__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_ones__4 :: Int -> Int -> IO IMatrix +imatrix_ones__4 = casadi__IMatrix__ones__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__operator_plus" c_casadi__IMatrix__operator_plus + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__operator_plus + :: IMatrix -> IO IMatrix +casadi__IMatrix__operator_plus x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__operator_plus errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_operator_plus :: IMatrixClass a => a -> IO IMatrix +imatrix_operator_plus x = casadi__IMatrix__operator_plus (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__operator_minus" c_casadi__IMatrix__operator_minus + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__operator_minus + :: IMatrix -> IO IMatrix +casadi__IMatrix__operator_minus x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__operator_minus errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_operator_minus :: IMatrixClass a => a -> IO IMatrix +imatrix_operator_minus x = casadi__IMatrix__operator_minus (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__printDense" c_casadi__IMatrix__printDense + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__printDense + :: IMatrix -> IO () +casadi__IMatrix__printDense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__printDense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_printDense :: IMatrixClass a => a -> IO () +imatrix_printDense x = casadi__IMatrix__printDense (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__printScalar" c_casadi__IMatrix__printScalar + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__printScalar + :: IMatrix -> IO () +casadi__IMatrix__printScalar x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__printScalar errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_printScalar :: IMatrixClass a => a -> IO () +imatrix_printScalar x = casadi__IMatrix__printScalar (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__printSparse" c_casadi__IMatrix__printSparse + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__printSparse + :: IMatrix -> IO () +casadi__IMatrix__printSparse x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__printSparse errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_printSparse :: IMatrixClass a => a -> IO () +imatrix_printSparse x = casadi__IMatrix__printSparse (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__printSplit" c_casadi__IMatrix__printSplit + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO () +casadi__IMatrix__printSplit + :: IMatrix -> Vector String -> Vector String -> IO () +casadi__IMatrix__printSplit x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__printSplit errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_printSplit :: IMatrixClass a => a -> Vector String -> Vector String -> IO () +imatrix_printSplit x = casadi__IMatrix__printSplit (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__printVector" c_casadi__IMatrix__printVector + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__printVector + :: IMatrix -> IO () +casadi__IMatrix__printVector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__printVector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_printVector :: IMatrixClass a => a -> IO () +imatrix_printVector x = casadi__IMatrix__printVector (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__printme" c_casadi__IMatrix__printme + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__printme + :: IMatrix -> IMatrix -> IO IMatrix +casadi__IMatrix__printme x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__printme errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_printme :: IMatrixClass a => a -> IMatrix -> IO IMatrix +imatrix_printme x = casadi__IMatrix__printme (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__remove" c_casadi__IMatrix__remove + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__IMatrix__remove + :: IMatrix -> Vector Int -> Vector Int -> IO () +casadi__IMatrix__remove x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__remove errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_remove :: IMatrixClass a => a -> Vector Int -> Vector Int -> IO () +imatrix_remove x = casadi__IMatrix__remove (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__reserve__0" c_casadi__IMatrix__reserve__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () +casadi__IMatrix__reserve__0 + :: IMatrix -> Int -> Int -> IO () +casadi__IMatrix__reserve__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__reserve__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_reserve__0 :: IMatrixClass a => a -> Int -> Int -> IO () +imatrix_reserve__0 x = casadi__IMatrix__reserve__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__reserve__1" c_casadi__IMatrix__reserve__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () +casadi__IMatrix__reserve__1 + :: IMatrix -> Int -> IO () +casadi__IMatrix__reserve__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__reserve__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_reserve__1 :: IMatrixClass a => a -> Int -> IO () +imatrix_reserve__1 x = casadi__IMatrix__reserve__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__resetInput" c_casadi__IMatrix__resetInput + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__resetInput + :: IMatrix -> IO () +casadi__IMatrix__resetInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__resetInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_resetInput :: IMatrixClass a => a -> IO () +imatrix_resetInput x = casadi__IMatrix__resetInput (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__resize" c_casadi__IMatrix__resize + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO () +casadi__IMatrix__resize + :: IMatrix -> Int -> Int -> IO () +casadi__IMatrix__resize x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__resize errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_resize :: IMatrixClass a => a -> Int -> Int -> IO () +imatrix_resize x = casadi__IMatrix__resize (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__row" c_casadi__IMatrix__row + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt +casadi__IMatrix__row + :: IMatrix -> Int -> IO Int +casadi__IMatrix__row x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__row errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_row :: IMatrixClass a => a -> Int -> IO Int +imatrix_row x = casadi__IMatrix__row (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sanityCheck__0" c_casadi__IMatrix__sanityCheck__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__sanityCheck__0 + :: IMatrix -> IO () +casadi__IMatrix__sanityCheck__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sanityCheck__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sanityCheck__0 :: IMatrixClass a => a -> IO () +imatrix_sanityCheck__0 x = casadi__IMatrix__sanityCheck__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sanityCheck__1" c_casadi__IMatrix__sanityCheck__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO () +casadi__IMatrix__sanityCheck__1 + :: IMatrix -> Bool -> IO () +casadi__IMatrix__sanityCheck__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sanityCheck__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sanityCheck__1 :: IMatrixClass a => a -> Bool -> IO () +imatrix_sanityCheck__1 x = casadi__IMatrix__sanityCheck__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__scalar_matrix" c_casadi__IMatrix__scalar_matrix + :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__scalar_matrix + :: Int -> IMatrix -> IMatrix -> IO IMatrix +casadi__IMatrix__scalar_matrix x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__scalar_matrix errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_scalar_matrix :: Int -> IMatrix -> IMatrix -> IO IMatrix +imatrix_scalar_matrix = casadi__IMatrix__scalar_matrix + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__0" c_casadi__IMatrix__set__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__IMatrix__set__0 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () +casadi__IMatrix__set__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IMatrix -> IO () +imatrix_set__0 x = casadi__IMatrix__set__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__1" c_casadi__IMatrix__set__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__IMatrix__set__1 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> Slice -> IO () +casadi__IMatrix__set__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__1 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> Slice -> IO () +imatrix_set__1 x = casadi__IMatrix__set__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__2" c_casadi__IMatrix__set__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__IMatrix__set__2 + :: IMatrix -> IMatrix -> Bool -> Slice -> IMatrix -> IO () +casadi__IMatrix__set__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__2 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IMatrix -> IO () +imatrix_set__2 x = casadi__IMatrix__set__2 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__3" c_casadi__IMatrix__set__3 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__IMatrix__set__3 + :: IMatrix -> IMatrix -> Bool -> Slice -> Slice -> IO () +casadi__IMatrix__set__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__3 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> Slice -> IO () +imatrix_set__3 x = casadi__IMatrix__set__3 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__4" c_casadi__IMatrix__set__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Sparsity' -> IO () +casadi__IMatrix__set__4 + :: IMatrix -> IMatrix -> Bool -> Sparsity -> IO () +casadi__IMatrix__set__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__4 :: IMatrixClass a => a -> IMatrix -> Bool -> Sparsity -> IO () +imatrix_set__4 x = casadi__IMatrix__set__4 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__5" c_casadi__IMatrix__set__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__IMatrix__set__5 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () +casadi__IMatrix__set__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__5 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () +imatrix_set__5 x = casadi__IMatrix__set__5 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__6" c_casadi__IMatrix__set__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__IMatrix__set__6 + :: IMatrix -> IMatrix -> Bool -> Slice -> IO () +casadi__IMatrix__set__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__6 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () +imatrix_set__6 x = casadi__IMatrix__set__6 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__7" c_casadi__IMatrix__set__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__IMatrix__set__7 + :: IMatrix -> Vector Double -> IO () +casadi__IMatrix__set__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__7 :: IMatrixClass a => a -> Vector Double -> IO () +imatrix_set__7 x = casadi__IMatrix__set__7 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__8" c_casadi__IMatrix__set__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__IMatrix__set__8 + :: IMatrix -> Vector Double -> Bool -> IO () +casadi__IMatrix__set__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__8 :: IMatrixClass a => a -> Vector Double -> Bool -> IO () +imatrix_set__8 x = casadi__IMatrix__set__8 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__9" c_casadi__IMatrix__set__9 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () +casadi__IMatrix__set__9 + :: IMatrix -> Double -> IO () +casadi__IMatrix__set__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__9 :: IMatrixClass a => a -> Double -> IO () +imatrix_set__9 x = casadi__IMatrix__set__9 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__set__10" c_casadi__IMatrix__set__10 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__IMatrix__set__10 + :: IMatrix -> IMatrix -> IO () +casadi__IMatrix__set__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__set__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_set__10 :: IMatrixClass a => a -> IMatrix -> IO () +imatrix_set__10 x = casadi__IMatrix__set__10 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__0" c_casadi__IMatrix__setEqualityCheckingDepth__0 + :: Ptr (Ptr StdString) -> IO () +casadi__IMatrix__setEqualityCheckingDepth__0 + :: IO () +casadi__IMatrix__setEqualityCheckingDepth__0 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setEqualityCheckingDepth__0 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setEqualityCheckingDepth__0 :: IO () +imatrix_setEqualityCheckingDepth__0 = casadi__IMatrix__setEqualityCheckingDepth__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setEqualityCheckingDepth__1" c_casadi__IMatrix__setEqualityCheckingDepth__1 + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__IMatrix__setEqualityCheckingDepth__1 + :: Int -> IO () +casadi__IMatrix__setEqualityCheckingDepth__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setEqualityCheckingDepth__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setEqualityCheckingDepth__1 :: Int -> IO () +imatrix_setEqualityCheckingDepth__1 = casadi__IMatrix__setEqualityCheckingDepth__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setNZ__0" c_casadi__IMatrix__setNZ__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO () +casadi__IMatrix__setNZ__0 + :: IMatrix -> IMatrix -> Bool -> IMatrix -> IO () +casadi__IMatrix__setNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setNZ__0 :: IMatrixClass a => a -> IMatrix -> Bool -> IMatrix -> IO () +imatrix_setNZ__0 x = casadi__IMatrix__setNZ__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setNZ__1" c_casadi__IMatrix__setNZ__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr Slice' -> IO () +casadi__IMatrix__setNZ__1 + :: IMatrix -> IMatrix -> Bool -> Slice -> IO () +casadi__IMatrix__setNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setNZ__1 :: IMatrixClass a => a -> IMatrix -> Bool -> Slice -> IO () +imatrix_setNZ__1 x = casadi__IMatrix__setNZ__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setNZ__2" c_casadi__IMatrix__setNZ__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__IMatrix__setNZ__2 + :: IMatrix -> Vector Double -> IO () +casadi__IMatrix__setNZ__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setNZ__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setNZ__2 :: IMatrixClass a => a -> Vector Double -> IO () +imatrix_setNZ__2 x = casadi__IMatrix__setNZ__2 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setNZ__3" c_casadi__IMatrix__setNZ__3 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () +casadi__IMatrix__setNZ__3 + :: IMatrix -> Double -> IO () +casadi__IMatrix__setNZ__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setNZ__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setNZ__3 :: IMatrixClass a => a -> Double -> IO () +imatrix_setNZ__3 x = casadi__IMatrix__setNZ__3 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setPrecision" c_casadi__IMatrix__setPrecision + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__IMatrix__setPrecision + :: Int -> IO () +casadi__IMatrix__setPrecision x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setPrecision errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setPrecision :: Int -> IO () +imatrix_setPrecision = casadi__IMatrix__setPrecision + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setScientific" c_casadi__IMatrix__setScientific + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__IMatrix__setScientific + :: Bool -> IO () +casadi__IMatrix__setScientific x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setScientific errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setScientific :: Bool -> IO () +imatrix_setScientific = casadi__IMatrix__setScientific + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setSym" c_casadi__IMatrix__setSym + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CDouble) -> IO () +casadi__IMatrix__setSym + :: IMatrix -> Vector Double -> IO () +casadi__IMatrix__setSym x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setSym errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setSym :: IMatrixClass a => a -> Vector Double -> IO () +imatrix_setSym x = casadi__IMatrix__setSym (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setValue__0" c_casadi__IMatrix__setValue__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> CInt -> IO () +casadi__IMatrix__setValue__0 + :: IMatrix -> Double -> Int -> IO () +casadi__IMatrix__setValue__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setValue__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setValue__0 :: IMatrixClass a => a -> Double -> Int -> IO () +imatrix_setValue__0 x = casadi__IMatrix__setValue__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setValue__1" c_casadi__IMatrix__setValue__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO () +casadi__IMatrix__setValue__1 + :: IMatrix -> Double -> IO () +casadi__IMatrix__setValue__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setValue__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setValue__1 :: IMatrixClass a => a -> Double -> IO () +imatrix_setValue__1 x = casadi__IMatrix__setValue__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setWidth" c_casadi__IMatrix__setWidth + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__IMatrix__setWidth + :: Int -> IO () +casadi__IMatrix__setWidth x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setWidth errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setWidth :: Int -> IO () +imatrix_setWidth = casadi__IMatrix__setWidth + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__setZero" c_casadi__IMatrix__setZero + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO () +casadi__IMatrix__setZero + :: IMatrix -> IO () +casadi__IMatrix__setZero x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__setZero errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_setZero :: IMatrixClass a => a -> IO () +imatrix_setZero x = casadi__IMatrix__setZero (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__shape__0" c_casadi__IMatrix__shape__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO CInt +casadi__IMatrix__shape__0 + :: IMatrix -> Int -> IO Int +casadi__IMatrix__shape__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__shape__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_shape__0 :: IMatrixClass a => a -> Int -> IO Int +imatrix_shape__0 x = casadi__IMatrix__shape__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__shape__1" c_casadi__IMatrix__shape__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdPair CInt CInt)) +casadi__IMatrix__shape__1 + :: IMatrix -> IO (Int, Int) +casadi__IMatrix__shape__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__shape__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_shape__1 :: IMatrixClass a => a -> IO (Int, Int) +imatrix_shape__1 x = casadi__IMatrix__shape__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__size" c_casadi__IMatrix__size + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__size + :: IMatrix -> IO Int +casadi__IMatrix__size x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__size errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_size :: IMatrixClass a => a -> IO Int +imatrix_size x = casadi__IMatrix__size (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__size1" c_casadi__IMatrix__size1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__size1 + :: IMatrix -> IO Int +casadi__IMatrix__size1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__size1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_size1 :: IMatrixClass a => a -> IO Int +imatrix_size1 x = casadi__IMatrix__size1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__size2" c_casadi__IMatrix__size2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__size2 + :: IMatrix -> IO Int +casadi__IMatrix__size2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__size2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_size2 :: IMatrixClass a => a -> IO Int +imatrix_size2 x = casadi__IMatrix__size2 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sizeD" c_casadi__IMatrix__sizeD + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__sizeD + :: IMatrix -> IO Int +casadi__IMatrix__sizeD x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sizeD errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sizeD :: IMatrixClass a => a -> IO Int +imatrix_sizeD x = casadi__IMatrix__sizeD (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sizeL" c_casadi__IMatrix__sizeL + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__sizeL + :: IMatrix -> IO Int +casadi__IMatrix__sizeL x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sizeL errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sizeL :: IMatrixClass a => a -> IO Int +imatrix_sizeL x = casadi__IMatrix__sizeL (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sizeU" c_casadi__IMatrix__sizeU + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi__IMatrix__sizeU + :: IMatrix -> IO Int +casadi__IMatrix__sizeU x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sizeU errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sizeU :: IMatrixClass a => a -> IO Int +imatrix_sizeU x = casadi__IMatrix__sizeU (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sparse__0" c_casadi__IMatrix__sparse__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__sparse__0 + :: Sparsity -> IMatrix -> IO IMatrix +casadi__IMatrix__sparse__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sparse__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sparse__0 :: Sparsity -> IMatrix -> IO IMatrix +imatrix_sparse__0 = casadi__IMatrix__sparse__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sparse__1" c_casadi__IMatrix__sparse__1 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi__IMatrix__sparse__1 + :: (Int, Int) -> IO IMatrix +casadi__IMatrix__sparse__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sparse__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sparse__1 :: (Int, Int) -> IO IMatrix +imatrix_sparse__1 = casadi__IMatrix__sparse__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sparse__2" c_casadi__IMatrix__sparse__2 + :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') +casadi__IMatrix__sparse__2 + :: IO IMatrix +casadi__IMatrix__sparse__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sparse__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sparse__2 :: IO IMatrix +imatrix_sparse__2 = casadi__IMatrix__sparse__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sparse__3" c_casadi__IMatrix__sparse__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__sparse__3 + :: Int -> IO IMatrix +casadi__IMatrix__sparse__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sparse__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sparse__3 :: Int -> IO IMatrix +imatrix_sparse__3 = casadi__IMatrix__sparse__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sparse__4" c_casadi__IMatrix__sparse__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__sparse__4 + :: Int -> Int -> IO IMatrix +casadi__IMatrix__sparse__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sparse__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sparse__4 :: Int -> Int -> IO IMatrix +imatrix_sparse__4 = casadi__IMatrix__sparse__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sparsity" c_casadi__IMatrix__sparsity + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Sparsity') +casadi__IMatrix__sparsity + :: IMatrix -> IO Sparsity +casadi__IMatrix__sparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sparsity :: IMatrixClass a => a -> IO Sparsity +imatrix_sparsity x = casadi__IMatrix__sparsity (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__0" c_casadi__IMatrix__sym__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) +casadi__IMatrix__sym__0 + :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix)) +casadi__IMatrix__sym__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector IMatrix)) +imatrix_sym__0 = casadi__IMatrix__sym__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__1" c_casadi__IMatrix__sym__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) +casadi__IMatrix__sym__1 + :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix)) +casadi__IMatrix__sym__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector IMatrix)) +imatrix_sym__1 = casadi__IMatrix__sym__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__2" c_casadi__IMatrix__sym__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi__IMatrix__sym__2 + :: String -> Int -> Int -> Int -> IO (Vector IMatrix) +casadi__IMatrix__sym__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__2 :: String -> Int -> Int -> Int -> IO (Vector IMatrix) +imatrix_sym__2 = casadi__IMatrix__sym__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__3" c_casadi__IMatrix__sym__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi__IMatrix__sym__3 + :: String -> Sparsity -> Int -> IO (Vector IMatrix) +casadi__IMatrix__sym__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__3 :: String -> Sparsity -> Int -> IO (Vector IMatrix) +imatrix_sym__3 = casadi__IMatrix__sym__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__4" c_casadi__IMatrix__sym__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi__IMatrix__sym__4 + :: String -> Sparsity -> IO IMatrix +casadi__IMatrix__sym__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__4 :: String -> Sparsity -> IO IMatrix +imatrix_sym__4 = casadi__IMatrix__sym__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__5" c_casadi__IMatrix__sym__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi__IMatrix__sym__5 + :: String -> (Int, Int) -> IO IMatrix +casadi__IMatrix__sym__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__5 :: String -> (Int, Int) -> IO IMatrix +imatrix_sym__5 = casadi__IMatrix__sym__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__6" c_casadi__IMatrix__sym__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr IMatrix') +casadi__IMatrix__sym__6 + :: String -> IO IMatrix +casadi__IMatrix__sym__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__6 :: String -> IO IMatrix +imatrix_sym__6 = casadi__IMatrix__sym__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__7" c_casadi__IMatrix__sym__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__sym__7 + :: String -> Int -> IO IMatrix +casadi__IMatrix__sym__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__7 :: String -> Int -> IO IMatrix +imatrix_sym__7 = casadi__IMatrix__sym__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__sym__8" c_casadi__IMatrix__sym__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__sym__8 + :: String -> Int -> Int -> IO IMatrix +casadi__IMatrix__sym__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__sym__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_sym__8 :: String -> Int -> Int -> IO IMatrix +imatrix_sym__8 = casadi__IMatrix__sym__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__toSlice__0" c_casadi__IMatrix__toSlice__0 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr Slice') +casadi__IMatrix__toSlice__0 + :: IMatrix -> IO Slice +casadi__IMatrix__toSlice__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__toSlice__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_toSlice__0 :: IMatrixClass a => a -> IO Slice +imatrix_toSlice__0 x = casadi__IMatrix__toSlice__0 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__toSlice__1" c_casadi__IMatrix__toSlice__1 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr Slice') +casadi__IMatrix__toSlice__1 + :: IMatrix -> Bool -> IO Slice +casadi__IMatrix__toSlice__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__toSlice__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_toSlice__1 :: IMatrixClass a => a -> Bool -> IO Slice +imatrix_toSlice__1 x = casadi__IMatrix__toSlice__1 (castIMatrix x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__triplet__0" c_casadi__IMatrix__triplet__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi__IMatrix__triplet__0 + :: Vector Int -> Vector Int -> IMatrix -> (Int, Int) -> IO IMatrix +casadi__IMatrix__triplet__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__triplet__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_triplet__0 :: Vector Int -> Vector Int -> IMatrix -> (Int, Int) -> IO IMatrix +imatrix_triplet__0 = casadi__IMatrix__triplet__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__triplet__1" c_casadi__IMatrix__triplet__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__triplet__1 + :: Vector Int -> Vector Int -> IMatrix -> Int -> Int -> IO IMatrix +casadi__IMatrix__triplet__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__triplet__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_triplet__1 :: Vector Int -> Vector Int -> IMatrix -> Int -> Int -> IO IMatrix +imatrix_triplet__1 = casadi__IMatrix__triplet__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__triplet__2" c_casadi__IMatrix__triplet__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__triplet__2 + :: Vector Int -> Vector Int -> IMatrix -> IO IMatrix +casadi__IMatrix__triplet__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__triplet__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_triplet__2 :: Vector Int -> Vector Int -> IMatrix -> IO IMatrix +imatrix_triplet__2 = casadi__IMatrix__triplet__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__unary" c_casadi__IMatrix__unary + :: Ptr (Ptr StdString) -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi__IMatrix__unary + :: Int -> IMatrix -> IO IMatrix +casadi__IMatrix__unary x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__unary errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_unary :: Int -> IMatrix -> IO IMatrix +imatrix_unary = casadi__IMatrix__unary + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__zeros__0" c_casadi__IMatrix__zeros__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi__IMatrix__zeros__0 + :: (Int, Int) -> IO IMatrix +casadi__IMatrix__zeros__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__zeros__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_zeros__0 :: (Int, Int) -> IO IMatrix +imatrix_zeros__0 = casadi__IMatrix__zeros__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__zeros__1" c_casadi__IMatrix__zeros__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi__IMatrix__zeros__1 + :: Sparsity -> IO IMatrix +casadi__IMatrix__zeros__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__zeros__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_zeros__1 :: Sparsity -> IO IMatrix +imatrix_zeros__1 = casadi__IMatrix__zeros__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__zeros__2" c_casadi__IMatrix__zeros__2 + :: Ptr (Ptr StdString) -> IO (Ptr IMatrix') +casadi__IMatrix__zeros__2 + :: IO IMatrix +casadi__IMatrix__zeros__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__zeros__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_zeros__2 :: IO IMatrix +imatrix_zeros__2 = casadi__IMatrix__zeros__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__zeros__3" c_casadi__IMatrix__zeros__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__zeros__3 + :: Int -> IO IMatrix +casadi__IMatrix__zeros__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__zeros__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_zeros__3 :: Int -> IO IMatrix +imatrix_zeros__3 = casadi__IMatrix__zeros__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__IMatrix__zeros__4" c_casadi__IMatrix__zeros__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr IMatrix') +casadi__IMatrix__zeros__4 + :: Int -> Int -> IO IMatrix +casadi__IMatrix__zeros__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IMatrix__zeros__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +imatrix_zeros__4 :: Int -> Int -> IO IMatrix +imatrix_zeros__4 = casadi__IMatrix__zeros__4 -- direct wrapper diff --git a/Casadi/Core/Classes/IOInterfaceFunction.hs b/Casadi/Core/Classes/IOInterfaceFunction.hs --- a/Casadi/Core/Classes/IOInterfaceFunction.hs +++ b/Casadi/Core/Classes/IOInterfaceFunction.hs @@ -9,59 +9,31 @@ ( IOInterfaceFunction, IOInterfaceFunctionClass(..), - ioInterfaceFunction_getInputScheme, ioInterfaceFunction_getInput__0, ioInterfaceFunction_getInput__1, ioInterfaceFunction_getInput__2, - ioInterfaceFunction_getNumInputs, - ioInterfaceFunction_getNumOutputs, - ioInterfaceFunction_getOutputScheme, ioInterfaceFunction_getOutput__0, ioInterfaceFunction_getOutput__1, ioInterfaceFunction_getOutput__2, - ioInterfaceFunction_inputSchemeEntry, - ioInterfaceFunction_input__0, - ioInterfaceFunction_input__1, - ioInterfaceFunction_input__2, - ioInterfaceFunction_input__3, - ioInterfaceFunction_input__4, - ioInterfaceFunction_input__5, - ioInterfaceFunction_outputSchemeEntry, - ioInterfaceFunction_output__0, - ioInterfaceFunction_output__1, - ioInterfaceFunction_output__2, - ioInterfaceFunction_output__3, - ioInterfaceFunction_output__4, - ioInterfaceFunction_output__5, - ioInterfaceFunction_schemeEntry, - ioInterfaceFunction_setInputScheme, + ioInterfaceFunction_setInputNZ__0, + ioInterfaceFunction_setInputNZ__1, + ioInterfaceFunction_setInputNZ__2, ioInterfaceFunction_setInput__0, ioInterfaceFunction_setInput__1, ioInterfaceFunction_setInput__2, - ioInterfaceFunction_setInput__3, - ioInterfaceFunction_setInput__4, - ioInterfaceFunction_setInput__5, - ioInterfaceFunction_setInput__6, - ioInterfaceFunction_setInput__7, - ioInterfaceFunction_setInput__8, - ioInterfaceFunction_setNumInputs, - ioInterfaceFunction_setNumOutputs, - ioInterfaceFunction_setOutputScheme, + ioInterfaceFunction_setOutputNZ__0, + ioInterfaceFunction_setOutputNZ__1, + ioInterfaceFunction_setOutputNZ__2, ioInterfaceFunction_setOutput__0, ioInterfaceFunction_setOutput__1, ioInterfaceFunction_setOutput__2, - ioInterfaceFunction_setOutput__3, - ioInterfaceFunction_setOutput__4, - ioInterfaceFunction_setOutput__5, - ioInterfaceFunction_setOutput__6, - ioInterfaceFunction_setOutput__7, - ioInterfaceFunction_setOutput__8, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -69,9 +41,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data @@ -139,66 +110,6 @@ -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getInputScheme" c_casadi__IOInterface_casadi__Function___getInputScheme - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr IOScheme') -casadi__IOInterface_casadi__Function___getInputScheme - :: IOInterfaceFunction -> IO IOScheme -casadi__IOInterface_casadi__Function___getInputScheme x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___getInputScheme errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_getInputScheme :: IOInterfaceFunctionClass a => a -> IO IOScheme -ioInterfaceFunction_getInputScheme x = casadi__IOInterface_casadi__Function___getInputScheme (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getNumInputs" c_casadi__IOInterface_casadi__Function___getNumInputs - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO CInt -casadi__IOInterface_casadi__Function___getNumInputs - :: IOInterfaceFunction -> IO Int -casadi__IOInterface_casadi__Function___getNumInputs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___getNumInputs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_getNumInputs :: IOInterfaceFunctionClass a => a -> IO Int -ioInterfaceFunction_getNumInputs x = casadi__IOInterface_casadi__Function___getNumInputs (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getNumOutputs" c_casadi__IOInterface_casadi__Function___getNumOutputs - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO CInt -casadi__IOInterface_casadi__Function___getNumOutputs - :: IOInterfaceFunction -> IO Int -casadi__IOInterface_casadi__Function___getNumOutputs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___getNumOutputs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_getNumOutputs :: IOInterfaceFunctionClass a => a -> IO Int -ioInterfaceFunction_getNumOutputs x = casadi__IOInterface_casadi__Function___getNumOutputs (castIOInterfaceFunction x) - - --- direct wrapper foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getOutput__0" c_casadi__IOInterface_casadi__Function___getOutput__0 :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix') casadi__IOInterface_casadi__Function___getOutput__0 @@ -261,339 +172,6 @@ -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___getOutputScheme" c_casadi__IOInterface_casadi__Function___getOutputScheme - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr IOScheme') -casadi__IOInterface_casadi__Function___getOutputScheme - :: IOInterfaceFunction -> IO IOScheme -casadi__IOInterface_casadi__Function___getOutputScheme x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___getOutputScheme errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_getOutputScheme :: IOInterfaceFunctionClass a => a -> IO IOScheme -ioInterfaceFunction_getOutputScheme x = casadi__IOInterface_casadi__Function___getOutputScheme (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___input__0" c_casadi__IOInterface_casadi__Function___input__0 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___input__0 - :: IOInterfaceFunction -> String -> IO DMatrix -casadi__IOInterface_casadi__Function___input__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___input__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_input__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix -ioInterfaceFunction_input__0 x = casadi__IOInterface_casadi__Function___input__0 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___input__1" c_casadi__IOInterface_casadi__Function___input__1 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___input__1 - :: IOInterfaceFunction -> IO DMatrix -casadi__IOInterface_casadi__Function___input__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___input__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_input__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix -ioInterfaceFunction_input__1 x = casadi__IOInterface_casadi__Function___input__1 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___input__2" c_casadi__IOInterface_casadi__Function___input__2 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___input__2 - :: IOInterfaceFunction -> Int -> IO DMatrix -casadi__IOInterface_casadi__Function___input__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___input__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_input__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix -ioInterfaceFunction_input__2 x = casadi__IOInterface_casadi__Function___input__2 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___input__3" c_casadi__IOInterface_casadi__Function___input__3 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___input__3 - :: IOInterfaceFunction -> String -> IO DMatrix -casadi__IOInterface_casadi__Function___input__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___input__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_input__3 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix -ioInterfaceFunction_input__3 x = casadi__IOInterface_casadi__Function___input__3 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___input__4" c_casadi__IOInterface_casadi__Function___input__4 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___input__4 - :: IOInterfaceFunction -> IO DMatrix -casadi__IOInterface_casadi__Function___input__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___input__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_input__4 :: IOInterfaceFunctionClass a => a -> IO DMatrix -ioInterfaceFunction_input__4 x = casadi__IOInterface_casadi__Function___input__4 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___input__5" c_casadi__IOInterface_casadi__Function___input__5 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___input__5 - :: IOInterfaceFunction -> Int -> IO DMatrix -casadi__IOInterface_casadi__Function___input__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___input__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_input__5 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix -ioInterfaceFunction_input__5 x = casadi__IOInterface_casadi__Function___input__5 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___inputSchemeEntry" c_casadi__IOInterface_casadi__Function___inputSchemeEntry - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO CInt -casadi__IOInterface_casadi__Function___inputSchemeEntry - :: IOInterfaceFunction -> String -> IO Int -casadi__IOInterface_casadi__Function___inputSchemeEntry x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___inputSchemeEntry errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_inputSchemeEntry :: IOInterfaceFunctionClass a => a -> String -> IO Int -ioInterfaceFunction_inputSchemeEntry x = casadi__IOInterface_casadi__Function___inputSchemeEntry (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___output__0" c_casadi__IOInterface_casadi__Function___output__0 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___output__0 - :: IOInterfaceFunction -> String -> IO DMatrix -casadi__IOInterface_casadi__Function___output__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___output__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_output__0 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix -ioInterfaceFunction_output__0 x = casadi__IOInterface_casadi__Function___output__0 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___output__1" c_casadi__IOInterface_casadi__Function___output__1 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___output__1 - :: IOInterfaceFunction -> IO DMatrix -casadi__IOInterface_casadi__Function___output__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___output__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_output__1 :: IOInterfaceFunctionClass a => a -> IO DMatrix -ioInterfaceFunction_output__1 x = casadi__IOInterface_casadi__Function___output__1 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___output__2" c_casadi__IOInterface_casadi__Function___output__2 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___output__2 - :: IOInterfaceFunction -> Int -> IO DMatrix -casadi__IOInterface_casadi__Function___output__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___output__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_output__2 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix -ioInterfaceFunction_output__2 x = casadi__IOInterface_casadi__Function___output__2 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___output__3" c_casadi__IOInterface_casadi__Function___output__3 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___output__3 - :: IOInterfaceFunction -> String -> IO DMatrix -casadi__IOInterface_casadi__Function___output__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___output__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_output__3 :: IOInterfaceFunctionClass a => a -> String -> IO DMatrix -ioInterfaceFunction_output__3 x = casadi__IOInterface_casadi__Function___output__3 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___output__4" c_casadi__IOInterface_casadi__Function___output__4 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___output__4 - :: IOInterfaceFunction -> IO DMatrix -casadi__IOInterface_casadi__Function___output__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___output__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_output__4 :: IOInterfaceFunctionClass a => a -> IO DMatrix -ioInterfaceFunction_output__4 x = casadi__IOInterface_casadi__Function___output__4 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___output__5" c_casadi__IOInterface_casadi__Function___output__5 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO (Ptr DMatrix') -casadi__IOInterface_casadi__Function___output__5 - :: IOInterfaceFunction -> Int -> IO DMatrix -casadi__IOInterface_casadi__Function___output__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___output__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_output__5 :: IOInterfaceFunctionClass a => a -> Int -> IO DMatrix -ioInterfaceFunction_output__5 x = casadi__IOInterface_casadi__Function___output__5 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___outputSchemeEntry" c_casadi__IOInterface_casadi__Function___outputSchemeEntry - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr StdString -> IO CInt -casadi__IOInterface_casadi__Function___outputSchemeEntry - :: IOInterfaceFunction -> String -> IO Int -casadi__IOInterface_casadi__Function___outputSchemeEntry x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___outputSchemeEntry errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_outputSchemeEntry :: IOInterfaceFunctionClass a => a -> String -> IO Int -ioInterfaceFunction_outputSchemeEntry x = casadi__IOInterface_casadi__Function___outputSchemeEntry (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___schemeEntry" c_casadi__IOInterface_casadi__Function___schemeEntry - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr IOScheme' -> Ptr StdString -> CInt -> IO CInt -casadi__IOInterface_casadi__Function___schemeEntry - :: IOInterfaceFunction -> IOScheme -> String -> Bool -> IO Int -casadi__IOInterface_casadi__Function___schemeEntry x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___schemeEntry errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_schemeEntry :: IOInterfaceFunctionClass a => a -> IOScheme -> String -> Bool -> IO Int -ioInterfaceFunction_schemeEntry x = casadi__IOInterface_casadi__Function___schemeEntry (castIOInterfaceFunction x) - - --- direct wrapper foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__0" c_casadi__IOInterface_casadi__Function___setInput__0 :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString -> IO () casadi__IOInterface_casadi__Function___setInput__0 @@ -659,196 +237,68 @@ -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__3" c_casadi__IOInterface_casadi__Function___setInput__3 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr (StdVec CDouble) -> Ptr StdString -> IO () -casadi__IOInterface_casadi__Function___setInput__3 - :: IOInterfaceFunction -> Vector Double -> String -> IO () -casadi__IOInterface_casadi__Function___setInput__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setInput__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setInput__3 :: IOInterfaceFunctionClass a => a -> Vector Double -> String -> IO () -ioInterfaceFunction_setInput__3 x = casadi__IOInterface_casadi__Function___setInput__3 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__4" c_casadi__IOInterface_casadi__Function___setInput__4 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr (StdVec CDouble) -> IO () -casadi__IOInterface_casadi__Function___setInput__4 - :: IOInterfaceFunction -> Vector Double -> IO () -casadi__IOInterface_casadi__Function___setInput__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setInput__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setInput__4 :: IOInterfaceFunctionClass a => a -> Vector Double -> IO () -ioInterfaceFunction_setInput__4 x = casadi__IOInterface_casadi__Function___setInput__4 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__5" c_casadi__IOInterface_casadi__Function___setInput__5 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__IOInterface_casadi__Function___setInput__5 - :: IOInterfaceFunction -> Vector Double -> Int -> IO () -casadi__IOInterface_casadi__Function___setInput__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setInput__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setInput__5 :: IOInterfaceFunctionClass a => a -> Vector Double -> Int -> IO () -ioInterfaceFunction_setInput__5 x = casadi__IOInterface_casadi__Function___setInput__5 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__6" c_casadi__IOInterface_casadi__Function___setInput__6 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CDouble -> Ptr StdString -> IO () -casadi__IOInterface_casadi__Function___setInput__6 - :: IOInterfaceFunction -> Double -> String -> IO () -casadi__IOInterface_casadi__Function___setInput__6 x0 x1 x2 = +foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInputNZ__0" c_casadi__IOInterface_casadi__Function___setInputNZ__0 + :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString -> IO () +casadi__IOInterface_casadi__Function___setInputNZ__0 + :: IOInterfaceFunction -> DMatrix -> String -> IO () +casadi__IOInterface_casadi__Function___setInputNZ__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setInput__6 errStrPtrP x0' x1' x2' + ret <- c_casadi__IOInterface_casadi__Function___setInputNZ__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -ioInterfaceFunction_setInput__6 :: IOInterfaceFunctionClass a => a -> Double -> String -> IO () -ioInterfaceFunction_setInput__6 x = casadi__IOInterface_casadi__Function___setInput__6 (castIOInterfaceFunction x) +ioInterfaceFunction_setInputNZ__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO () +ioInterfaceFunction_setInputNZ__0 x = casadi__IOInterface_casadi__Function___setInputNZ__0 (castIOInterfaceFunction x) -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__7" c_casadi__IOInterface_casadi__Function___setInput__7 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CDouble -> IO () -casadi__IOInterface_casadi__Function___setInput__7 - :: IOInterfaceFunction -> Double -> IO () -casadi__IOInterface_casadi__Function___setInput__7 x0 x1 = +foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInputNZ__1" c_casadi__IOInterface_casadi__Function___setInputNZ__1 + :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO () +casadi__IOInterface_casadi__Function___setInputNZ__1 + :: IOInterfaceFunction -> DMatrix -> IO () +casadi__IOInterface_casadi__Function___setInputNZ__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setInput__7 errStrPtrP x0' x1' + ret <- c_casadi__IOInterface_casadi__Function___setInputNZ__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -ioInterfaceFunction_setInput__7 :: IOInterfaceFunctionClass a => a -> Double -> IO () -ioInterfaceFunction_setInput__7 x = casadi__IOInterface_casadi__Function___setInput__7 (castIOInterfaceFunction x) +ioInterfaceFunction_setInputNZ__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO () +ioInterfaceFunction_setInputNZ__1 x = casadi__IOInterface_casadi__Function___setInputNZ__1 (castIOInterfaceFunction x) -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInput__8" c_casadi__IOInterface_casadi__Function___setInput__8 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CDouble -> CInt -> IO () -casadi__IOInterface_casadi__Function___setInput__8 - :: IOInterfaceFunction -> Double -> Int -> IO () -casadi__IOInterface_casadi__Function___setInput__8 x0 x1 x2 = +foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInputNZ__2" c_casadi__IOInterface_casadi__Function___setInputNZ__2 + :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO () +casadi__IOInterface_casadi__Function___setInputNZ__2 + :: IOInterfaceFunction -> DMatrix -> Int -> IO () +casadi__IOInterface_casadi__Function___setInputNZ__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setInput__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setInput__8 :: IOInterfaceFunctionClass a => a -> Double -> Int -> IO () -ioInterfaceFunction_setInput__8 x = casadi__IOInterface_casadi__Function___setInput__8 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setInputScheme" c_casadi__IOInterface_casadi__Function___setInputScheme - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr IOScheme' -> IO () -casadi__IOInterface_casadi__Function___setInputScheme - :: IOInterfaceFunction -> IOScheme -> IO () -casadi__IOInterface_casadi__Function___setInputScheme x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setInputScheme errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setInputScheme :: IOInterfaceFunctionClass a => a -> IOScheme -> IO () -ioInterfaceFunction_setInputScheme x = casadi__IOInterface_casadi__Function___setInputScheme (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setNumInputs" c_casadi__IOInterface_casadi__Function___setNumInputs - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO () -casadi__IOInterface_casadi__Function___setNumInputs - :: IOInterfaceFunction -> Int -> IO () -casadi__IOInterface_casadi__Function___setNumInputs x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setNumInputs errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setNumInputs :: IOInterfaceFunctionClass a => a -> Int -> IO () -ioInterfaceFunction_setNumInputs x = casadi__IOInterface_casadi__Function___setNumInputs (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setNumOutputs" c_casadi__IOInterface_casadi__Function___setNumOutputs - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CInt -> IO () -casadi__IOInterface_casadi__Function___setNumOutputs - :: IOInterfaceFunction -> Int -> IO () -casadi__IOInterface_casadi__Function___setNumOutputs x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setNumOutputs errStrPtrP x0' x1' + ret <- c_casadi__IOInterface_casadi__Function___setInputNZ__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -ioInterfaceFunction_setNumOutputs :: IOInterfaceFunctionClass a => a -> Int -> IO () -ioInterfaceFunction_setNumOutputs x = casadi__IOInterface_casadi__Function___setNumOutputs (castIOInterfaceFunction x) +ioInterfaceFunction_setInputNZ__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO () +ioInterfaceFunction_setInputNZ__2 x = casadi__IOInterface_casadi__Function___setInputNZ__2 (castIOInterfaceFunction x) -- direct wrapper @@ -917,152 +367,66 @@ -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__3" c_casadi__IOInterface_casadi__Function___setOutput__3 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr (StdVec CDouble) -> Ptr StdString -> IO () -casadi__IOInterface_casadi__Function___setOutput__3 - :: IOInterfaceFunction -> Vector Double -> String -> IO () -casadi__IOInterface_casadi__Function___setOutput__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setOutput__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setOutput__3 :: IOInterfaceFunctionClass a => a -> Vector Double -> String -> IO () -ioInterfaceFunction_setOutput__3 x = casadi__IOInterface_casadi__Function___setOutput__3 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__4" c_casadi__IOInterface_casadi__Function___setOutput__4 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr (StdVec CDouble) -> IO () -casadi__IOInterface_casadi__Function___setOutput__4 - :: IOInterfaceFunction -> Vector Double -> IO () -casadi__IOInterface_casadi__Function___setOutput__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setOutput__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setOutput__4 :: IOInterfaceFunctionClass a => a -> Vector Double -> IO () -ioInterfaceFunction_setOutput__4 x = casadi__IOInterface_casadi__Function___setOutput__4 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__5" c_casadi__IOInterface_casadi__Function___setOutput__5 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__IOInterface_casadi__Function___setOutput__5 - :: IOInterfaceFunction -> Vector Double -> Int -> IO () -casadi__IOInterface_casadi__Function___setOutput__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setOutput__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setOutput__5 :: IOInterfaceFunctionClass a => a -> Vector Double -> Int -> IO () -ioInterfaceFunction_setOutput__5 x = casadi__IOInterface_casadi__Function___setOutput__5 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__6" c_casadi__IOInterface_casadi__Function___setOutput__6 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CDouble -> Ptr StdString -> IO () -casadi__IOInterface_casadi__Function___setOutput__6 - :: IOInterfaceFunction -> Double -> String -> IO () -casadi__IOInterface_casadi__Function___setOutput__6 x0 x1 x2 = +foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutputNZ__0" c_casadi__IOInterface_casadi__Function___setOutputNZ__0 + :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> Ptr StdString -> IO () +casadi__IOInterface_casadi__Function___setOutputNZ__0 + :: IOInterfaceFunction -> DMatrix -> String -> IO () +casadi__IOInterface_casadi__Function___setOutputNZ__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setOutput__6 errStrPtrP x0' x1' x2' + ret <- c_casadi__IOInterface_casadi__Function___setOutputNZ__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -ioInterfaceFunction_setOutput__6 :: IOInterfaceFunctionClass a => a -> Double -> String -> IO () -ioInterfaceFunction_setOutput__6 x = casadi__IOInterface_casadi__Function___setOutput__6 (castIOInterfaceFunction x) +ioInterfaceFunction_setOutputNZ__0 :: IOInterfaceFunctionClass a => a -> DMatrix -> String -> IO () +ioInterfaceFunction_setOutputNZ__0 x = casadi__IOInterface_casadi__Function___setOutputNZ__0 (castIOInterfaceFunction x) -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__7" c_casadi__IOInterface_casadi__Function___setOutput__7 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CDouble -> IO () -casadi__IOInterface_casadi__Function___setOutput__7 - :: IOInterfaceFunction -> Double -> IO () -casadi__IOInterface_casadi__Function___setOutput__7 x0 x1 = +foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutputNZ__1" c_casadi__IOInterface_casadi__Function___setOutputNZ__1 + :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> IO () +casadi__IOInterface_casadi__Function___setOutputNZ__1 + :: IOInterfaceFunction -> DMatrix -> IO () +casadi__IOInterface_casadi__Function___setOutputNZ__1 x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setOutput__7 errStrPtrP x0' x1' + ret <- c_casadi__IOInterface_casadi__Function___setOutputNZ__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -ioInterfaceFunction_setOutput__7 :: IOInterfaceFunctionClass a => a -> Double -> IO () -ioInterfaceFunction_setOutput__7 x = casadi__IOInterface_casadi__Function___setOutput__7 (castIOInterfaceFunction x) +ioInterfaceFunction_setOutputNZ__1 :: IOInterfaceFunctionClass a => a -> DMatrix -> IO () +ioInterfaceFunction_setOutputNZ__1 x = casadi__IOInterface_casadi__Function___setOutputNZ__1 (castIOInterfaceFunction x) -- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutput__8" c_casadi__IOInterface_casadi__Function___setOutput__8 - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> CDouble -> CInt -> IO () -casadi__IOInterface_casadi__Function___setOutput__8 - :: IOInterfaceFunction -> Double -> Int -> IO () -casadi__IOInterface_casadi__Function___setOutput__8 x0 x1 x2 = +foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutputNZ__2" c_casadi__IOInterface_casadi__Function___setOutputNZ__2 + :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr DMatrix' -> CInt -> IO () +casadi__IOInterface_casadi__Function___setOutputNZ__2 + :: IOInterfaceFunction -> DMatrix -> Int -> IO () +casadi__IOInterface_casadi__Function___setOutputNZ__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setOutput__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioInterfaceFunction_setOutput__8 :: IOInterfaceFunctionClass a => a -> Double -> Int -> IO () -ioInterfaceFunction_setOutput__8 x = casadi__IOInterface_casadi__Function___setOutput__8 (castIOInterfaceFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOInterface_casadi__Function___setOutputScheme" c_casadi__IOInterface_casadi__Function___setOutputScheme - :: Ptr (Ptr StdString) -> Ptr IOInterfaceFunction' -> Ptr IOScheme' -> IO () -casadi__IOInterface_casadi__Function___setOutputScheme - :: IOInterfaceFunction -> IOScheme -> IO () -casadi__IOInterface_casadi__Function___setOutputScheme x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOInterface_casadi__Function___setOutputScheme errStrPtrP x0' x1' + ret <- c_casadi__IOInterface_casadi__Function___setOutputNZ__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -ioInterfaceFunction_setOutputScheme :: IOInterfaceFunctionClass a => a -> IOScheme -> IO () -ioInterfaceFunction_setOutputScheme x = casadi__IOInterface_casadi__Function___setOutputScheme (castIOInterfaceFunction x) +ioInterfaceFunction_setOutputNZ__2 :: IOInterfaceFunctionClass a => a -> DMatrix -> Int -> IO () +ioInterfaceFunction_setOutputNZ__2 x = casadi__IOInterface_casadi__Function___setOutputNZ__2 (castIOInterfaceFunction x) diff --git a/Casadi/Core/Classes/IOScheme.hs b/Casadi/Core/Classes/IOScheme.hs deleted file mode 100644 --- a/Casadi/Core/Classes/IOScheme.hs +++ /dev/null @@ -1,985 +0,0 @@ -{-# OPTIONS_GHC -Wall #-} -{-# OPTIONS_GHC -fno-warn-unused-imports #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# Language ForeignFunctionInterface #-} -{-# Language FlexibleInstances #-} -{-# Language MultiParamTypeClasses #-} - -module Casadi.Core.Classes.IOScheme - ( - IOScheme, - IOSchemeClass(..), - ioScheme__0, - ioScheme__1, - ioScheme__10, - ioScheme__11, - ioScheme__12, - ioScheme__13, - ioScheme__14, - ioScheme__15, - ioScheme__16, - ioScheme__17, - ioScheme__18, - ioScheme__19, - ioScheme__2, - ioScheme__20, - ioScheme__21, - ioScheme__22, - ioScheme__23, - ioScheme__3, - ioScheme__4, - ioScheme__5, - ioScheme__6, - ioScheme__7, - ioScheme__8, - ioScheme__9, - 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.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__0" c_casadi__IOScheme__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__0 - :: String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__0 :: String -> IO IOScheme -ioScheme__0 = casadi__IOScheme__CONSTRUCTOR__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__1" c_casadi__IOScheme__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__1 - :: String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__1 :: String -> String -> IO IOScheme -ioScheme__1 = casadi__IOScheme__CONSTRUCTOR__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__2" c_casadi__IOScheme__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__2 - :: String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__2 :: String -> String -> String -> IO IOScheme -ioScheme__2 = casadi__IOScheme__CONSTRUCTOR__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__3" c_casadi__IOScheme__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__3 - :: String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__3 :: String -> String -> String -> String -> IO IOScheme -ioScheme__3 = casadi__IOScheme__CONSTRUCTOR__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__4" c_casadi__IOScheme__CONSTRUCTOR__4 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__4 - :: String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__4 :: String -> String -> String -> String -> String -> IO IOScheme -ioScheme__4 = casadi__IOScheme__CONSTRUCTOR__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__5" c_casadi__IOScheme__CONSTRUCTOR__5 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__5 - :: String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__5 :: String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__5 = casadi__IOScheme__CONSTRUCTOR__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__6" c_casadi__IOScheme__CONSTRUCTOR__6 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__6 - :: String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__6 :: String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__6 = casadi__IOScheme__CONSTRUCTOR__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__7" c_casadi__IOScheme__CONSTRUCTOR__7 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__7 - :: String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__7 :: String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__7 = casadi__IOScheme__CONSTRUCTOR__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__8" c_casadi__IOScheme__CONSTRUCTOR__8 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__8 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__8 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__8 = casadi__IOScheme__CONSTRUCTOR__8 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__9" c_casadi__IOScheme__CONSTRUCTOR__9 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__9 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__9 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__9 = casadi__IOScheme__CONSTRUCTOR__9 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__10" c_casadi__IOScheme__CONSTRUCTOR__10 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__10 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__10 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__10 = casadi__IOScheme__CONSTRUCTOR__10 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__11" c_casadi__IOScheme__CONSTRUCTOR__11 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__11 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__11 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__11 = casadi__IOScheme__CONSTRUCTOR__11 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__12" c_casadi__IOScheme__CONSTRUCTOR__12 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__12 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__12 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__12 = casadi__IOScheme__CONSTRUCTOR__12 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__13" c_casadi__IOScheme__CONSTRUCTOR__13 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__13 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - withMarshal x13 $ \x13' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__13 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__13 = casadi__IOScheme__CONSTRUCTOR__13 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__14" c_casadi__IOScheme__CONSTRUCTOR__14 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__14 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - withMarshal x13 $ \x13' -> - withMarshal x14 $ \x14' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__14 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__14 = casadi__IOScheme__CONSTRUCTOR__14 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__15" c_casadi__IOScheme__CONSTRUCTOR__15 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__15 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - withMarshal x13 $ \x13' -> - withMarshal x14 $ \x14' -> - withMarshal x15 $ \x15' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__15 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__15 = casadi__IOScheme__CONSTRUCTOR__15 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__16" c_casadi__IOScheme__CONSTRUCTOR__16 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__16 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - withMarshal x13 $ \x13' -> - withMarshal x14 $ \x14' -> - withMarshal x15 $ \x15' -> - withMarshal x16 $ \x16' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__16 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__16 = casadi__IOScheme__CONSTRUCTOR__16 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__17" c_casadi__IOScheme__CONSTRUCTOR__17 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__17 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - withMarshal x13 $ \x13' -> - withMarshal x14 $ \x14' -> - withMarshal x15 $ \x15' -> - withMarshal x16 $ \x16' -> - withMarshal x17 $ \x17' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__17 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__17 = casadi__IOScheme__CONSTRUCTOR__17 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__18" c_casadi__IOScheme__CONSTRUCTOR__18 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__18 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - withMarshal x13 $ \x13' -> - withMarshal x14 $ \x14' -> - withMarshal x15 $ \x15' -> - withMarshal x16 $ \x16' -> - withMarshal x17 $ \x17' -> - withMarshal x18 $ \x18' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__18 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__18 = casadi__IOScheme__CONSTRUCTOR__18 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__19" c_casadi__IOScheme__CONSTRUCTOR__19 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__19 - :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - withMarshal x13 $ \x13' -> - withMarshal x14 $ \x14' -> - withMarshal x15 $ \x15' -> - withMarshal x16 $ \x16' -> - withMarshal x17 $ \x17' -> - withMarshal x18 $ \x18' -> - withMarshal x19 $ \x19' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__19 :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO IOScheme -ioScheme__19 = casadi__IOScheme__CONSTRUCTOR__19 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__20" c_casadi__IOScheme__CONSTRUCTOR__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__20 - :: Vector String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__20 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__20 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__20 :: Vector String -> IO IOScheme -ioScheme__20 = casadi__IOScheme__CONSTRUCTOR__20 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__21" c_casadi__IOScheme__CONSTRUCTOR__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__21 - :: Vector String -> Vector String -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__21 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__21 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__21 :: Vector String -> Vector String -> IO IOScheme -ioScheme__21 = casadi__IOScheme__CONSTRUCTOR__21 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__22" c_casadi__IOScheme__CONSTRUCTOR__22 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__22 - :: InputOutputScheme -> IO IOScheme -casadi__IOScheme__CONSTRUCTOR__22 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__22 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__22 :: InputOutputScheme -> IO IOScheme -ioScheme__22 = casadi__IOScheme__CONSTRUCTOR__22 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__23" c_casadi__IOScheme__CONSTRUCTOR__23 - :: Ptr (Ptr StdString) -> IO (Ptr IOScheme') -casadi__IOScheme__CONSTRUCTOR__23 - :: IO IOScheme -casadi__IOScheme__CONSTRUCTOR__23 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__CONSTRUCTOR__23 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme__23 :: IO IOScheme -ioScheme__23 = casadi__IOScheme__CONSTRUCTOR__23 - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__compatibleSize" c_casadi__IOScheme__compatibleSize - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> CInt -> IO CInt -casadi__IOScheme__compatibleSize - :: IOScheme -> Int -> IO Int -casadi__IOScheme__compatibleSize x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__compatibleSize errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_compatibleSize :: IOSchemeClass a => a -> Int -> IO Int -ioScheme_compatibleSize x = casadi__IOScheme__compatibleSize (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__describe" c_casadi__IOScheme__describe - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> CInt -> IO (Ptr StdString) -casadi__IOScheme__describe - :: IOScheme -> Int -> IO String -casadi__IOScheme__describe x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__describe errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_describe :: IOSchemeClass a => a -> Int -> IO String -ioScheme_describe x = casadi__IOScheme__describe (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__describeInput" c_casadi__IOScheme__describeInput - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> CInt -> IO (Ptr StdString) -casadi__IOScheme__describeInput - :: IOScheme -> Int -> IO String -casadi__IOScheme__describeInput x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__describeInput errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -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 (Ptr StdString) -> Ptr IOScheme' -> CInt -> IO (Ptr StdString) -casadi__IOScheme__describeOutput - :: IOScheme -> Int -> IO String -casadi__IOScheme__describeOutput x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__describeOutput errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_describeOutput :: IOSchemeClass a => a -> Int -> IO String -ioScheme_describeOutput x = casadi__IOScheme__describeOutput (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__entry" c_casadi__IOScheme__entry - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> CInt -> IO (Ptr StdString) -casadi__IOScheme__entry - :: IOScheme -> Int -> IO String -casadi__IOScheme__entry x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__entry errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_entry :: IOSchemeClass a => a -> Int -> IO String -ioScheme_entry x = casadi__IOScheme__entry (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__entryEnum" c_casadi__IOScheme__entryEnum - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> CInt -> IO (Ptr StdString) -casadi__IOScheme__entryEnum - :: IOScheme -> Int -> IO String -casadi__IOScheme__entryEnum x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__entryEnum errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_entryEnum :: IOSchemeClass a => a -> Int -> IO String -ioScheme_entryEnum x = casadi__IOScheme__entryEnum (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__entryLabel" c_casadi__IOScheme__entryLabel - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> CInt -> IO (Ptr StdString) -casadi__IOScheme__entryLabel - :: IOScheme -> Int -> IO String -casadi__IOScheme__entryLabel x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__entryLabel errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_entryLabel :: IOSchemeClass a => a -> Int -> IO String -ioScheme_entryLabel x = casadi__IOScheme__entryLabel (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__entryNames" c_casadi__IOScheme__entryNames - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> IO (Ptr StdString) -casadi__IOScheme__entryNames - :: IOScheme -> IO String -casadi__IOScheme__entryNames x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__entryNames errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -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 (Ptr StdString) -> Ptr IOScheme' -> Ptr StdString -> IO CInt -casadi__IOScheme__index - :: IOScheme -> String -> IO Int -casadi__IOScheme__index x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__index errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_index :: IOSchemeClass a => a -> String -> IO Int -ioScheme_index x = casadi__IOScheme__index (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__known" c_casadi__IOScheme__known - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> IO CInt -casadi__IOScheme__known - :: IOScheme -> IO Bool -casadi__IOScheme__known x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__known errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_known :: IOSchemeClass a => a -> IO Bool -ioScheme_known x = casadi__IOScheme__known (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__name" c_casadi__IOScheme__name - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> IO (Ptr StdString) -casadi__IOScheme__name - :: IOScheme -> IO String -casadi__IOScheme__name x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__name errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_name :: IOSchemeClass a => a -> IO String -ioScheme_name x = casadi__IOScheme__name (castIOScheme x) - - --- direct wrapper -foreign import ccall unsafe "casadi__IOScheme__size" c_casadi__IOScheme__size - :: Ptr (Ptr StdString) -> Ptr IOScheme' -> IO CInt -casadi__IOScheme__size - :: IOScheme -> IO Int -casadi__IOScheme__size x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__IOScheme__size errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -ioScheme_size :: IOSchemeClass a => a -> IO Int -ioScheme_size x = casadi__IOScheme__size (castIOScheme x) - diff --git a/Casadi/Core/Classes/ImplicitFunction.hs b/Casadi/Core/Classes/ImplicitFunction.hs --- a/Casadi/Core/Classes/ImplicitFunction.hs +++ b/Casadi/Core/Classes/ImplicitFunction.hs @@ -12,7 +12,6 @@ implicitFunction__0, implicitFunction__1, implicitFunction__2, - implicitFunction__3, implicitFunction_doc, implicitFunction_getF, implicitFunction_getJac, @@ -25,6 +24,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -32,97 +32,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__0" c_casadi__ImplicitFunction__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> IO (Ptr ImplicitFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr ImplicitFunction') casadi__ImplicitFunction__CONSTRUCTOR__0 - :: String -> Function -> IO ImplicitFunction -casadi__ImplicitFunction__CONSTRUCTOR__0 x0 x1 = + :: String -> String -> Function -> IO ImplicitFunction +casadi__ImplicitFunction__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -implicitFunction__0 :: String -> Function -> IO ImplicitFunction +implicitFunction__0 :: String -> String -> Function -> IO ImplicitFunction implicitFunction__0 = casadi__ImplicitFunction__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__1" c_casadi__ImplicitFunction__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> IO (Ptr ImplicitFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr ImplicitFunction') casadi__ImplicitFunction__CONSTRUCTOR__1 - :: String -> Function -> Function -> IO ImplicitFunction -casadi__ImplicitFunction__CONSTRUCTOR__1 x0 x1 x2 = + :: String -> String -> Function -> M.Map String GenericType -> IO ImplicitFunction +casadi__ImplicitFunction__CONSTRUCTOR__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' + ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -implicitFunction__1 :: String -> Function -> Function -> IO ImplicitFunction +implicitFunction__1 :: String -> String -> Function -> M.Map String GenericType -> IO ImplicitFunction implicitFunction__1 = casadi__ImplicitFunction__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__2" c_casadi__ImplicitFunction__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr LinearSolver' -> IO (Ptr ImplicitFunction') -casadi__ImplicitFunction__CONSTRUCTOR__2 - :: String -> Function -> Function -> LinearSolver -> IO ImplicitFunction -casadi__ImplicitFunction__CONSTRUCTOR__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -implicitFunction__2 :: String -> Function -> Function -> LinearSolver -> IO ImplicitFunction -implicitFunction__2 = casadi__ImplicitFunction__CONSTRUCTOR__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__ImplicitFunction__CONSTRUCTOR__3" c_casadi__ImplicitFunction__CONSTRUCTOR__3 :: Ptr (Ptr StdString) -> IO (Ptr ImplicitFunction') -casadi__ImplicitFunction__CONSTRUCTOR__3 +casadi__ImplicitFunction__CONSTRUCTOR__2 :: IO ImplicitFunction -casadi__ImplicitFunction__CONSTRUCTOR__3 = +casadi__ImplicitFunction__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__3 errStrPtrP + ret <- c_casadi__ImplicitFunction__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -implicitFunction__3 :: IO ImplicitFunction -implicitFunction__3 = casadi__ImplicitFunction__CONSTRUCTOR__3 +implicitFunction__2 :: IO ImplicitFunction +implicitFunction__2 = casadi__ImplicitFunction__CONSTRUCTOR__2 -- direct wrapper diff --git a/Casadi/Core/Classes/Integrator.hs b/Casadi/Core/Classes/Integrator.hs --- a/Casadi/Core/Classes/Integrator.hs +++ b/Casadi/Core/Classes/Integrator.hs @@ -12,8 +12,15 @@ integrator__0, integrator__1, integrator__2, + integrator__3, + integrator__4, + integrator__5, + integrator__6, + integrator__7, + integrator__8, integrator_clone, integrator_doc, + integrator_getAugmented, integrator_getDAE, integrator_hasPlugin, integrator_integrate, @@ -29,6 +36,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -36,74 +44,210 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__0" c_casadi__Integrator__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> IO (Ptr Integrator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr Integrator') casadi__Integrator__CONSTRUCTOR__0 - :: String -> Function -> IO Integrator -casadi__Integrator__CONSTRUCTOR__0 x0 x1 = + :: String -> String -> M.Map String MX -> IO Integrator +casadi__Integrator__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__Integrator__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__Integrator__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -integrator__0 :: String -> Function -> IO Integrator +integrator__0 :: String -> String -> M.Map String MX -> IO Integrator integrator__0 = casadi__Integrator__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__1" c_casadi__Integrator__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> IO (Ptr Integrator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator') casadi__Integrator__CONSTRUCTOR__1 - :: String -> Function -> Function -> IO Integrator -casadi__Integrator__CONSTRUCTOR__1 x0 x1 x2 = + :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO Integrator +casadi__Integrator__CONSTRUCTOR__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__Integrator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' + ret <- c_casadi__Integrator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -integrator__1 :: String -> Function -> Function -> IO Integrator +integrator__1 :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO Integrator integrator__1 = casadi__Integrator__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__2" c_casadi__Integrator__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> IO (Ptr Integrator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr Integrator') casadi__Integrator__CONSTRUCTOR__2 + :: String -> String -> M.Map String SX -> IO Integrator +casadi__Integrator__CONSTRUCTOR__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Integrator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +integrator__2 :: String -> String -> M.Map String SX -> IO Integrator +integrator__2 = casadi__Integrator__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__3" c_casadi__Integrator__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator') +casadi__Integrator__CONSTRUCTOR__3 + :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO Integrator +casadi__Integrator__CONSTRUCTOR__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Integrator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +integrator__3 :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO Integrator +integrator__3 = casadi__Integrator__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__4" c_casadi__Integrator__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdPair (Ptr Function') (Ptr Function')) -> IO (Ptr Integrator') +casadi__Integrator__CONSTRUCTOR__4 + :: String -> String -> (Function, Function) -> IO Integrator +casadi__Integrator__CONSTRUCTOR__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Integrator__CONSTRUCTOR__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +integrator__4 :: String -> String -> (Function, Function) -> IO Integrator +integrator__4 = casadi__Integrator__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__5" c_casadi__Integrator__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdPair (Ptr Function') (Ptr Function')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator') +casadi__Integrator__CONSTRUCTOR__5 + :: String -> String -> (Function, Function) -> M.Map String GenericType -> IO Integrator +casadi__Integrator__CONSTRUCTOR__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Integrator__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +integrator__5 :: String -> String -> (Function, Function) -> M.Map String GenericType -> IO Integrator +integrator__5 = casadi__Integrator__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__6" c_casadi__Integrator__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr Integrator') +casadi__Integrator__CONSTRUCTOR__6 + :: String -> String -> Function -> IO Integrator +casadi__Integrator__CONSTRUCTOR__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Integrator__CONSTRUCTOR__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +integrator__6 :: String -> String -> Function -> IO Integrator +integrator__6 = casadi__Integrator__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__7" c_casadi__Integrator__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Integrator') +casadi__Integrator__CONSTRUCTOR__7 + :: String -> String -> Function -> M.Map String GenericType -> IO Integrator +casadi__Integrator__CONSTRUCTOR__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Integrator__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +integrator__7 :: String -> String -> Function -> M.Map String GenericType -> IO Integrator +integrator__7 = casadi__Integrator__CONSTRUCTOR__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Integrator__CONSTRUCTOR__8" c_casadi__Integrator__CONSTRUCTOR__8 + :: Ptr (Ptr StdString) -> IO (Ptr Integrator') +casadi__Integrator__CONSTRUCTOR__8 :: IO Integrator -casadi__Integrator__CONSTRUCTOR__2 = +casadi__Integrator__CONSTRUCTOR__8 = do errStrPtrP <- new nullPtr - ret <- c_casadi__Integrator__CONSTRUCTOR__2 errStrPtrP + ret <- c_casadi__Integrator__CONSTRUCTOR__8 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -integrator__2 :: IO Integrator -integrator__2 = casadi__Integrator__CONSTRUCTOR__2 +integrator__8 :: IO Integrator +integrator__8 = casadi__Integrator__CONSTRUCTOR__8 -- direct wrapper @@ -144,6 +288,28 @@ -- classy wrapper integrator_doc :: String -> IO String integrator_doc = casadi__Integrator__doc + + +-- direct wrapper +foreign import ccall unsafe "casadi__Integrator__getAugmented" c_casadi__Integrator__getAugmented + :: Ptr (Ptr StdString) -> Ptr Integrator' -> CInt -> CInt -> IO (Ptr (StdPair (Ptr Function') (Ptr Function'))) +casadi__Integrator__getAugmented + :: Integrator -> Int -> Int -> IO (Function, Function) +casadi__Integrator__getAugmented x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Integrator__getAugmented errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +integrator_getAugmented :: IntegratorClass a => a -> Int -> Int -> IO (Function, Function) +integrator_getAugmented x = casadi__Integrator__getAugmented (castIntegrator x) -- direct wrapper diff --git a/Casadi/Core/Classes/IterationCallback.hs b/Casadi/Core/Classes/IterationCallback.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/IterationCallback.hs @@ -0,0 +1,73 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.IterationCallback + ( + IterationCallback, + IterationCallbackClass(..), + iterationCallback, + iterationCallback_operator_call, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__IterationCallback__CONSTRUCTOR" c_casadi__IterationCallback__CONSTRUCTOR + :: Ptr (Ptr StdString) -> IO (Ptr IterationCallback') +casadi__IterationCallback__CONSTRUCTOR + :: IO IterationCallback +casadi__IterationCallback__CONSTRUCTOR = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IterationCallback__CONSTRUCTOR errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +iterationCallback :: IO IterationCallback +iterationCallback = casadi__IterationCallback__CONSTRUCTOR + + +-- direct wrapper +foreign import ccall unsafe "casadi__IterationCallback__operator_call" c_casadi__IterationCallback__operator_call + :: Ptr (Ptr StdString) -> Ptr IterationCallback' -> Ptr Function' -> IO CInt +casadi__IterationCallback__operator_call + :: IterationCallback -> Function -> IO Int +casadi__IterationCallback__operator_call x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__IterationCallback__operator_call errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +iterationCallback_operator_call :: IterationCallbackClass a => a -> Function -> IO Int +iterationCallback_operator_call x = casadi__IterationCallback__operator_call (castIterationCallback x) + diff --git a/Casadi/Core/Classes/KernelSum2D.hs b/Casadi/Core/Classes/KernelSum2D.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/KernelSum2D.hs @@ -0,0 +1,102 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.KernelSum2D + ( + KernelSum2D, + KernelSum2DClass(..), + kernelSum2D__0, + kernelSum2D__1, + kernelSum2D__2, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__KernelSum2D__CONSTRUCTOR__0" c_casadi__KernelSum2D__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr (StdPair CInt CInt) -> CDouble -> CInt -> IO (Ptr KernelSum2D') +casadi__KernelSum2D__CONSTRUCTOR__0 + :: String -> Function -> (Int, Int) -> Double -> Int -> IO KernelSum2D +casadi__KernelSum2D__CONSTRUCTOR__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__KernelSum2D__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +kernelSum2D__0 :: String -> Function -> (Int, Int) -> Double -> Int -> IO KernelSum2D +kernelSum2D__0 = casadi__KernelSum2D__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__KernelSum2D__CONSTRUCTOR__1" c_casadi__KernelSum2D__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr (StdPair CInt CInt) -> CDouble -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr KernelSum2D') +casadi__KernelSum2D__CONSTRUCTOR__1 + :: String -> Function -> (Int, Int) -> Double -> Int -> M.Map String GenericType -> IO KernelSum2D +casadi__KernelSum2D__CONSTRUCTOR__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__KernelSum2D__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +kernelSum2D__1 :: String -> Function -> (Int, Int) -> Double -> Int -> M.Map String GenericType -> IO KernelSum2D +kernelSum2D__1 = casadi__KernelSum2D__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__KernelSum2D__CONSTRUCTOR__2" c_casadi__KernelSum2D__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> IO (Ptr KernelSum2D') +casadi__KernelSum2D__CONSTRUCTOR__2 + :: IO KernelSum2D +casadi__KernelSum2D__CONSTRUCTOR__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__KernelSum2D__CONSTRUCTOR__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +kernelSum2D__2 :: IO KernelSum2D +kernelSum2D__2 = casadi__KernelSum2D__CONSTRUCTOR__2 + diff --git a/Casadi/Core/Classes/LinearSolver.hs b/Casadi/Core/Classes/LinearSolver.hs --- a/Casadi/Core/Classes/LinearSolver.hs +++ b/Casadi/Core/Classes/LinearSolver.hs @@ -32,6 +32,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -39,94 +40,101 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__0" c_casadi__LinearSolver__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr LinearSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr LinearSolver') casadi__LinearSolver__CONSTRUCTOR__0 - :: String -> Sparsity -> IO LinearSolver -casadi__LinearSolver__CONSTRUCTOR__0 x0 x1 = + :: String -> String -> Sparsity -> Int -> IO LinearSolver +casadi__LinearSolver__CONSTRUCTOR__0 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__LinearSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__LinearSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -linearSolver__0 :: String -> Sparsity -> IO LinearSolver +linearSolver__0 :: String -> String -> Sparsity -> Int -> IO LinearSolver linearSolver__0 = casadi__LinearSolver__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__1" c_casadi__LinearSolver__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr LinearSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LinearSolver') casadi__LinearSolver__CONSTRUCTOR__1 - :: String -> Sparsity -> Int -> IO LinearSolver -casadi__LinearSolver__CONSTRUCTOR__1 x0 x1 x2 = + :: String -> String -> Sparsity -> Int -> M.Map String GenericType -> IO LinearSolver +casadi__LinearSolver__CONSTRUCTOR__1 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__LinearSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' + ret <- c_casadi__LinearSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -linearSolver__1 :: String -> Sparsity -> Int -> IO LinearSolver +linearSolver__1 :: String -> String -> Sparsity -> Int -> M.Map String GenericType -> IO LinearSolver linearSolver__1 = casadi__LinearSolver__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__2" c_casadi__LinearSolver__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr LinearSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr LinearSolver') casadi__LinearSolver__CONSTRUCTOR__2 - :: Sparsity -> IO LinearSolver -casadi__LinearSolver__CONSTRUCTOR__2 x0 = + :: String -> String -> Sparsity -> IO LinearSolver +casadi__LinearSolver__CONSTRUCTOR__2 x0 x1 x2 = withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__LinearSolver__CONSTRUCTOR__2 errStrPtrP x0' + ret <- c_casadi__LinearSolver__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -linearSolver__2 :: Sparsity -> IO LinearSolver +linearSolver__2 :: String -> String -> Sparsity -> IO LinearSolver linearSolver__2 = casadi__LinearSolver__CONSTRUCTOR__2 -- direct wrapper foreign import ccall unsafe "casadi__LinearSolver__CONSTRUCTOR__3" c_casadi__LinearSolver__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr LinearSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Sparsity' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LinearSolver') casadi__LinearSolver__CONSTRUCTOR__3 - :: Sparsity -> Int -> IO LinearSolver -casadi__LinearSolver__CONSTRUCTOR__3 x0 x1 = + :: String -> String -> Sparsity -> M.Map String GenericType -> IO LinearSolver +casadi__LinearSolver__CONSTRUCTOR__3 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__LinearSolver__CONSTRUCTOR__3 errStrPtrP x0' x1' + ret <- c_casadi__LinearSolver__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -linearSolver__3 :: Sparsity -> Int -> IO LinearSolver +linearSolver__3 :: String -> String -> Sparsity -> M.Map String GenericType -> IO LinearSolver linearSolver__3 = casadi__LinearSolver__CONSTRUCTOR__3 diff --git a/Casadi/Core/Classes/LpSolver.hs b/Casadi/Core/Classes/LpSolver.hs --- a/Casadi/Core/Classes/LpSolver.hs +++ b/Casadi/Core/Classes/LpSolver.hs @@ -9,7 +9,9 @@ ( LpSolver, LpSolverClass(..), - lpSolver, + lpSolver__0, + lpSolver__1, + lpSolver__2, lpSolver_doc, lpSolver_hasPlugin, lpSolver_loadPlugin, @@ -19,6 +21,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -26,31 +29,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR" c_casadi__LpSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR__0" c_casadi__LpSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr LpSolver') +casadi__LpSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO LpSolver +casadi__LpSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lpSolver__0 :: String -> String -> M.Map String Sparsity -> IO LpSolver +lpSolver__0 = casadi__LpSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR__1" c_casadi__LpSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LpSolver') +casadi__LpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LpSolver +casadi__LpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LpSolver +lpSolver__1 = casadi__LpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR__2" c_casadi__LpSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr LpSolver') -casadi__LpSolver__CONSTRUCTOR +casadi__LpSolver__CONSTRUCTOR__2 :: IO LpSolver -casadi__LpSolver__CONSTRUCTOR = +casadi__LpSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__LpSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__LpSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -lpSolver :: IO LpSolver -lpSolver = casadi__LpSolver__CONSTRUCTOR +lpSolver__2 :: IO LpSolver +lpSolver__2 = casadi__LpSolver__CONSTRUCTOR__2 -- direct wrapper diff --git a/Casadi/Core/Classes/LrDleSolver.hs b/Casadi/Core/Classes/LrDleSolver.hs --- a/Casadi/Core/Classes/LrDleSolver.hs +++ b/Casadi/Core/Classes/LrDleSolver.hs @@ -9,9 +9,13 @@ ( LrDleSolver, LrDleSolverClass(..), - lrDleSolver, + lrDleSolver__0, + lrDleSolver__1, + lrDleSolver__2, lrDleSolver_clone, lrDleSolver_doc, + lrDleSolver_getSparsity__0, + lrDleSolver_getSparsity__1, lrDleSolver_hasPlugin, lrDleSolver_loadPlugin, lrDleSolver_printStats, @@ -21,6 +25,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -28,31 +33,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__LrDleSolver__CONSTRUCTOR" c_casadi__LrDleSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__LrDleSolver__CONSTRUCTOR__0" c_casadi__LrDleSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr LrDleSolver') +casadi__LrDleSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO LrDleSolver +casadi__LrDleSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LrDleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lrDleSolver__0 :: String -> String -> M.Map String Sparsity -> IO LrDleSolver +lrDleSolver__0 = casadi__LrDleSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__LrDleSolver__CONSTRUCTOR__1" c_casadi__LrDleSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LrDleSolver') +casadi__LrDleSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LrDleSolver +casadi__LrDleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LrDleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lrDleSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO LrDleSolver +lrDleSolver__1 = casadi__LrDleSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__LrDleSolver__CONSTRUCTOR__2" c_casadi__LrDleSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr LrDleSolver') -casadi__LrDleSolver__CONSTRUCTOR +casadi__LrDleSolver__CONSTRUCTOR__2 :: IO LrDleSolver -casadi__LrDleSolver__CONSTRUCTOR = +casadi__LrDleSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__LrDleSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__LrDleSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -lrDleSolver :: IO LrDleSolver -lrDleSolver = casadi__LrDleSolver__CONSTRUCTOR +lrDleSolver__2 :: IO LrDleSolver +lrDleSolver__2 = casadi__LrDleSolver__CONSTRUCTOR__2 -- direct wrapper @@ -93,6 +142,47 @@ -- classy wrapper lrDleSolver_doc :: String -> IO String lrDleSolver_doc = casadi__LrDleSolver__doc + + +-- direct wrapper +foreign import ccall unsafe "casadi__LrDleSolver__getSparsity__0" c_casadi__LrDleSolver__getSparsity__0 + :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr Sparsity') +casadi__LrDleSolver__getSparsity__0 + :: M.Map String Sparsity -> IO Sparsity +casadi__LrDleSolver__getSparsity__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LrDleSolver__getSparsity__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lrDleSolver_getSparsity__0 :: M.Map String Sparsity -> IO Sparsity +lrDleSolver_getSparsity__0 = casadi__LrDleSolver__getSparsity__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__LrDleSolver__getSparsity__1" c_casadi__LrDleSolver__getSparsity__1 + :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__LrDleSolver__getSparsity__1 + :: M.Map String Sparsity -> Vector Int -> IO Sparsity +casadi__LrDleSolver__getSparsity__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LrDleSolver__getSparsity__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lrDleSolver_getSparsity__1 :: M.Map String Sparsity -> Vector Int -> IO Sparsity +lrDleSolver_getSparsity__1 = casadi__LrDleSolver__getSparsity__1 -- direct wrapper diff --git a/Casadi/Core/Classes/LrDpleSolver.hs b/Casadi/Core/Classes/LrDpleSolver.hs --- a/Casadi/Core/Classes/LrDpleSolver.hs +++ b/Casadi/Core/Classes/LrDpleSolver.hs @@ -9,7 +9,9 @@ ( LrDpleSolver, LrDpleSolverClass(..), - lrDpleSolver, + lrDpleSolver__0, + lrDpleSolver__1, + lrDpleSolver__2, lrDpleSolver_clone, lrDpleSolver_doc, lrDpleSolver_hasPlugin, @@ -21,6 +23,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -28,31 +31,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__LrDpleSolver__CONSTRUCTOR" c_casadi__LrDpleSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__LrDpleSolver__CONSTRUCTOR__0" c_casadi__LrDpleSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr LrDpleSolver') +casadi__LrDpleSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String (Vector Sparsity) -> IO LrDpleSolver +casadi__LrDpleSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LrDpleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lrDpleSolver__0 :: String -> String -> M.Map String (Vector Sparsity) -> IO LrDpleSolver +lrDpleSolver__0 = casadi__LrDpleSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__LrDpleSolver__CONSTRUCTOR__1" c_casadi__LrDpleSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr (StdVec (Ptr Sparsity')))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr LrDpleSolver') +casadi__LrDpleSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO LrDpleSolver +casadi__LrDpleSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__LrDpleSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +lrDpleSolver__1 :: String -> String -> M.Map String (Vector Sparsity) -> M.Map String GenericType -> IO LrDpleSolver +lrDpleSolver__1 = casadi__LrDpleSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__LrDpleSolver__CONSTRUCTOR__2" c_casadi__LrDpleSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr LrDpleSolver') -casadi__LrDpleSolver__CONSTRUCTOR +casadi__LrDpleSolver__CONSTRUCTOR__2 :: IO LrDpleSolver -casadi__LrDpleSolver__CONSTRUCTOR = +casadi__LrDpleSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__LrDpleSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__LrDpleSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -lrDpleSolver :: IO LrDpleSolver -lrDpleSolver = casadi__LrDpleSolver__CONSTRUCTOR +lrDpleSolver__2 :: IO LrDpleSolver +lrDpleSolver__2 = casadi__LrDpleSolver__CONSTRUCTOR__2 -- direct wrapper diff --git a/Casadi/Core/Classes/MX.hs b/Casadi/Core/Classes/MX.hs --- a/Casadi/Core/Classes/MX.hs +++ b/Casadi/Core/Classes/MX.hs @@ -18,6145 +18,3443 @@ mx__5, mx__6, mx__7, - mx___constpow__, - mx___copysign__, - mx___hash__, - mx___mldivide__, - mx___mrdivide__, - mx___nonzero__, - mx___truediv____0, - mx___truediv____1, - mx_addToSum, - mx_append, - mx_appendColumns, - mx_attachAssert__0, - mx_attachAssert__1, - mx_binary, - mx_colind, - mx_constpow, - mx_dimString, - mx_enlarge__0, - mx_enlarge__1, - mx_erase__0, - mx_erase__1, - mx_erase__2, - mx_erase__3, - mx_eye, - mx_find__0, - mx_find__1, - mx_getColind, - mx_getDep__0, - mx_getDep__1, - mx_getEqualityCheckingDepth, - mx_getEvaluationOutput, - mx_getFunction, - mx_getMatrixValue, - mx_getMaxNumCallsInPrint, - mx_getNZ__0, - mx_getNZ__1, - mx_getName, - mx_getNdeps, - mx_getNumOutputs, - mx_getOp, - mx_getOutput__0, - mx_getOutput__1, - mx_getRow, - mx_getSparsity, - mx_getTemp, - mx_getValue, - mx_get__0, - mx_get__1, - mx_get__2, - mx_get__3, - mx_get__4, - mx_get__5, - mx_get__6, - mx_inf__0, - mx_inf__1, - mx_inf__2, - mx_inf__3, - mx_isBinary, - mx_isCommutative, - mx_isConstant, - mx_isDense, - mx_isEmpty__0, - mx_isEmpty__1, - mx_isEvaluation, - mx_isEvaluationOutput, - mx_isIdentity, - mx_isMinusOne, - mx_isMultiplication, - mx_isNorm, - mx_isOne, - mx_isOperation, - mx_isRegular, - mx_isRowVector, - mx_isScalar__0, - mx_isScalar__1, - mx_isSquare, - mx_isSymbolic, - mx_isSymbolicSparse, - mx_isTranspose, - mx_isTril, - mx_isTriu, - mx_isUnary, - mx_isVector__0, - mx_isVector__1, - mx_isZero, - mx_lift, - mx_makeDense__0, - mx_makeDense__1, - mx_mapping, - mx_nan__0, - mx_nan__1, - mx_nan__2, - mx_nan__3, - mx_nnz, - mx_numel__0, - mx_numel__1, - mx_ones__0, - mx_ones__1, - mx_ones__2, - mx_ones__3, - mx_operator_minus, - mx_printme, - mx_row, - mx_setEqualityCheckingDepth__0, - mx_setEqualityCheckingDepth__1, - mx_setMaxNumCallsInPrint__0, - mx_setMaxNumCallsInPrint__1, - mx_setNZ__0, - mx_setNZ__1, - mx_setSparse__0, - mx_setSparse__1, - mx_setTemp, - mx_set__0, - mx_set__1, - mx_set__2, - mx_set__3, - mx_set__4, - mx_set__5, - mx_set__6, - mx_size1, - mx_size2, - mx_sizeD, - mx_sizeL, - mx_sizeU, - mx_size__0, - mx_size__1, - mx_sparse__0, - mx_sparse__1, - mx_sparse__2, - mx_sparse__3, - mx_sparsity, - mx_sparsityRef, - mx_sym__0, - mx_sym__1, - mx_sym__2, - mx_sym__3, - mx_sym__4, - mx_sym__5, - mx_sym__6, - mx_sym__7, - mx_unary, - mx_zeros__0, - mx_zeros__1, - mx_zeros__2, - mx_zeros__3, - mx_zz_abs, - mx_zz_acos, - mx_zz_acosh, - mx_zz_and, - mx_zz_asin, - mx_zz_asinh, - mx_zz_atan, - mx_zz_atan2, - mx_zz_atanh, - mx_zz_blockcat, - mx_zz_blocksplit, - mx_zz_ceil, - mx_zz_cos, - mx_zz_cosh, - mx_zz_countNodes, - mx_zz_createParent__0, - mx_zz_createParent__1, - mx_zz_createParent__2, - mx_zz_cross__0, - mx_zz_cross__1, - mx_zz_densify, - mx_zz_dependsOn, - mx_zz_det, - mx_zz_diag, - mx_zz_diagcat, - mx_zz_diagsplit, - mx_zz_eq, - mx_zz_erf, - mx_zz_erfinv, - mx_zz_exp, - mx_zz_extractShared__0, - mx_zz_extractShared__1, - mx_zz_extractShared__2, - mx_zz_floor, - mx_zz_ge, - mx_zz_getOperatorRepresentation, - mx_zz_getSymbols__0, - mx_zz_getSymbols__1, - mx_zz_gradient, - mx_zz_graph_substitute__0, - mx_zz_graph_substitute__1, - mx_zz_gt, - mx_zz_hessian__0, - mx_zz_hessian__1, - mx_zz_horzcat, - mx_zz_horzsplit, - mx_zz_if_else, - mx_zz_if_else_zero, - mx_zz_inner_prod, - mx_zz_inv, - mx_zz_isEqual__0, - mx_zz_isEqual__1, - mx_zz_jacobian, - mx_zz_kron, - mx_zz_le, - mx_zz_linspace, - mx_zz_log, - mx_zz_log10, - mx_zz_lt, - mx_zz_matrix_expand__0, - mx_zz_matrix_expand__1, - mx_zz_matrix_expand__2, - mx_zz_matrix_expand__3, - mx_zz_max, - mx_zz_min, - mx_zz_minus, - mx_zz_mod, - mx_zz_mpower, - mx_zz_mtimes__0, - mx_zz_mtimes__1, - mx_zz_ne, - mx_zz_norm_0_mul, - mx_zz_norm_1, - mx_zz_norm_2, - mx_zz_norm_F, - mx_zz_norm_inf, - mx_zz_not, - mx_zz_nullspace, - mx_zz_or, - mx_zz_outer_prod, - mx_zz_pinv, - mx_zz_plus, - mx_zz_polyval, - mx_zz_power, - mx_zz_printCompact, - mx_zz_quad_form__0, - mx_zz_quad_form__1, - mx_zz_rdivide, - mx_zz_repmat__0, - mx_zz_repmat__1, - mx_zz_reshape__0, - mx_zz_reshape__1, - mx_zz_sign, - mx_zz_simplify, - mx_zz_sin, - mx_zz_sinh, - mx_zz_solve, - mx_zz_sprank, - mx_zz_sqrt, - mx_zz_substituteInPlace__0, - mx_zz_substituteInPlace__1, - mx_zz_substituteInPlace__2, - mx_zz_substituteInPlace__3, - mx_zz_substitute__0, - mx_zz_substitute__1, - mx_zz_sumAll, - mx_zz_sumCols, - mx_zz_sumRows, - mx_zz_sum_square, - mx_zz_tan, - mx_zz_tangent, - mx_zz_tanh, - mx_zz_times, - mx_zz_trace, - mx_zz_tril2symm, - mx_zz_tril__0, - mx_zz_tril__1, - mx_zz_triu2symm, - mx_zz_triu__0, - mx_zz_triu__1, - mx_zz_unite, - mx_zz_vec, - mx_zz_vecNZ, - mx_zz_vecNZcat, - mx_zz_veccat, - mx_zz_vertcat, - mx_zz_vertsplit, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__0" c_casadi__MX__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__0 - :: DMatrix -> IO MX -casadi__MX__CONSTRUCTOR__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__0 :: DMatrix -> IO MX -mx__0 = casadi__MX__CONSTRUCTOR__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__1" c_casadi__MX__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__1 - :: Vector Double -> IO MX -casadi__MX__CONSTRUCTOR__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__1 :: Vector Double -> IO MX -mx__1 = casadi__MX__CONSTRUCTOR__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__2" c_casadi__MX__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__2 - :: MX -> IO MX -casadi__MX__CONSTRUCTOR__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__2 :: MX -> IO MX -mx__2 = casadi__MX__CONSTRUCTOR__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__3" c_casadi__MX__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__3 - :: Double -> IO MX -casadi__MX__CONSTRUCTOR__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__3 :: Double -> IO MX -mx__3 = casadi__MX__CONSTRUCTOR__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__4" c_casadi__MX__CONSTRUCTOR__4 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__4 - :: Sparsity -> MX -> IO MX -casadi__MX__CONSTRUCTOR__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__4 :: Sparsity -> MX -> IO MX -mx__4 = casadi__MX__CONSTRUCTOR__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__5" c_casadi__MX__CONSTRUCTOR__5 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__5 - :: Sparsity -> IO MX -casadi__MX__CONSTRUCTOR__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__5 :: Sparsity -> IO MX -mx__5 = casadi__MX__CONSTRUCTOR__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__6" c_casadi__MX__CONSTRUCTOR__6 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__6 - :: Int -> Int -> IO MX -casadi__MX__CONSTRUCTOR__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__6 :: Int -> Int -> IO MX -mx__6 = casadi__MX__CONSTRUCTOR__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__7" c_casadi__MX__CONSTRUCTOR__7 - :: Ptr (Ptr StdString) -> IO (Ptr MX') -casadi__MX__CONSTRUCTOR__7 - :: IO MX -casadi__MX__CONSTRUCTOR__7 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__CONSTRUCTOR__7 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx__7 :: IO MX -mx__7 = casadi__MX__CONSTRUCTOR__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__T" c_casadi__MX__T - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__T - :: MX -> IO MX -casadi__MX__T x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__T errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_T :: MXClass a => a -> IO MX -mx_T x = casadi__MX__T (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX____constpow__" c_casadi__MX____constpow__ - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____constpow__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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____copysign__" c_casadi__MX____copysign__ - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX____copysign__ - :: MX -> MX -> IO MX -casadi__MX____copysign__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____copysign__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx___copysign__ :: MXClass a => a -> MX -> IO MX -mx___copysign__ x = casadi__MX____copysign__ (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX____hash__" c_casadi__MX____hash__ - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CLong -casadi__MX____hash__ - :: MX -> IO Int -casadi__MX____hash__ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____hash__ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx___hash__ :: MXClass a => a -> IO Int -mx___hash__ x = casadi__MX____hash__ (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX____mldivide__" c_casadi__MX____mldivide__ - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX____mldivide__ - :: MX -> MX -> IO MX -casadi__MX____mldivide__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____mldivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx___mldivide__ :: MXClass a => a -> MX -> IO MX -mx___mldivide__ x = casadi__MX____mldivide__ (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX____mrdivide__" c_casadi__MX____mrdivide__ - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____mrdivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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____nonzero__" c_casadi__MX____nonzero__ - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX____nonzero__ - :: MX -> IO Bool -casadi__MX____nonzero__ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____nonzero__ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx___nonzero__ :: MXClass a => a -> IO Bool -mx___nonzero__ x = casadi__MX____nonzero__ (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX____truediv____0" c_casadi__MX____truediv____0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX____truediv____0 - :: MX -> MX -> IO MX -casadi__MX____truediv____0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____truediv____0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx___truediv____0 :: MXClass a => a -> MX -> IO MX -mx___truediv____0 x = casadi__MX____truediv____0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX____truediv____1" c_casadi__MX____truediv____1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX____truediv____1 - :: MX -> MX -> IO MX -casadi__MX____truediv____1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX____truediv____1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx___truediv____1 :: MXClass a => a -> MX -> IO MX -mx___truediv____1 x = casadi__MX____truediv____1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__addToSum" c_casadi__MX__addToSum - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () -casadi__MX__addToSum - :: MX -> MX -> IO () -casadi__MX__addToSum x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__addToSum errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_addToSum :: MXClass a => a -> MX -> IO () -mx_addToSum x = casadi__MX__addToSum (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__append" c_casadi__MX__append - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () -casadi__MX__append - :: MX -> MX -> IO () -casadi__MX__append x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__append errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_append :: MXClass a => a -> MX -> IO () -mx_append x = casadi__MX__append (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__appendColumns" c_casadi__MX__appendColumns - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () -casadi__MX__appendColumns - :: MX -> MX -> IO () -casadi__MX__appendColumns x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__appendColumns errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_appendColumns :: MXClass a => a -> MX -> IO () -mx_appendColumns x = casadi__MX__appendColumns (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__attachAssert__0" c_casadi__MX__attachAssert__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__attachAssert__0 - :: MX -> MX -> IO MX -casadi__MX__attachAssert__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__attachAssert__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_attachAssert__0 :: MXClass a => a -> MX -> IO MX -mx_attachAssert__0 x = casadi__MX__attachAssert__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__attachAssert__1" c_casadi__MX__attachAssert__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') -casadi__MX__attachAssert__1 - :: MX -> MX -> String -> IO MX -casadi__MX__attachAssert__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__attachAssert__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_attachAssert__1 :: MXClass a => a -> MX -> String -> IO MX -mx_attachAssert__1 x = casadi__MX__attachAssert__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__binary" c_casadi__MX__binary - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__binary errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_binary :: Int -> MX -> MX -> IO MX -mx_binary = casadi__MX__binary - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__colind" c_casadi__MX__colind - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__colind - :: MX -> Int -> IO Int -casadi__MX__colind x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__colind errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_colind :: MXClass a => a -> Int -> IO Int -mx_colind x = casadi__MX__colind (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__constpow" c_casadi__MX__constpow - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__constpow errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__dimString" c_casadi__MX__dimString - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString) -casadi__MX__dimString - :: MX -> IO String -casadi__MX__dimString x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__dimString errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_dimString :: MXClass a => a -> IO String -mx_dimString x = casadi__MX__dimString (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__enlarge__0" c_casadi__MX__enlarge__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__MX__enlarge__0 - :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO () -casadi__MX__enlarge__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_enlarge__0 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () -mx_enlarge__0 x = casadi__MX__enlarge__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__enlarge__1" c_casadi__MX__enlarge__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__MX__enlarge__1 - :: MX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -casadi__MX__enlarge__1 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_enlarge__1 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -mx_enlarge__1 x = casadi__MX__enlarge__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__erase__0" c_casadi__MX__erase__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO () -casadi__MX__erase__0 - :: MX -> Vector Int -> IO () -casadi__MX__erase__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__erase__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_erase__0 :: MXClass a => a -> Vector Int -> IO () -mx_erase__0 x = casadi__MX__erase__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__erase__1" c_casadi__MX__erase__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__MX__erase__1 - :: MX -> Vector Int -> Bool -> IO () -casadi__MX__erase__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__erase__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_erase__1 :: MXClass a => a -> Vector Int -> Bool -> IO () -mx_erase__1 x = casadi__MX__erase__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__erase__2" c_casadi__MX__erase__2 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__MX__erase__2 - :: MX -> Vector Int -> Vector Int -> IO () -casadi__MX__erase__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__erase__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_erase__2 :: MXClass a => a -> Vector Int -> Vector Int -> IO () -mx_erase__2 x = casadi__MX__erase__2 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__erase__3" c_casadi__MX__erase__3 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__MX__erase__3 - :: MX -> Vector Int -> Vector Int -> Bool -> IO () -casadi__MX__erase__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__erase__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_erase__3 :: MXClass a => a -> Vector Int -> Vector Int -> Bool -> IO () -mx_erase__3 x = casadi__MX__erase__3 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__eye" c_casadi__MX__eye - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') -casadi__MX__eye - :: Int -> IO MX -casadi__MX__eye x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__eye errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_eye :: Int -> IO MX -mx_eye = casadi__MX__eye - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__find__0" c_casadi__MX__find__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) -casadi__MX__find__0 - :: MX -> IO (Vector Int) -casadi__MX__find__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__find__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_find__0 :: MXClass a => a -> IO (Vector Int) -mx_find__0 x = casadi__MX__find__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__find__1" c_casadi__MX__find__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec CInt)) -casadi__MX__find__1 - :: MX -> Bool -> IO (Vector Int) -casadi__MX__find__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__find__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_find__1 :: MXClass a => a -> Bool -> IO (Vector Int) -mx_find__1 x = casadi__MX__find__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__get__0" c_casadi__MX__get__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__MX__get__0 - :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO () -casadi__MX__get__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__get__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_get__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO () -mx_get__0 x = casadi__MX__get__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__get__1" c_casadi__MX__get__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__MX__get__1 - :: MX -> MX -> Bool -> IMatrix -> Slice -> IO () -casadi__MX__get__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__get__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_get__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO () -mx_get__1 x = casadi__MX__get__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__get__2" c_casadi__MX__get__2 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__MX__get__2 - :: MX -> MX -> Bool -> Slice -> IMatrix -> IO () -casadi__MX__get__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__get__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_get__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO () -mx_get__2 x = casadi__MX__get__2 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__get__3" c_casadi__MX__get__3 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__MX__get__3 - :: MX -> MX -> Bool -> Slice -> Slice -> IO () -casadi__MX__get__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__get__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_get__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO () -mx_get__3 x = casadi__MX__get__3 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__get__4" c_casadi__MX__get__4 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO () -casadi__MX__get__4 - :: MX -> MX -> Bool -> Sparsity -> IO () -casadi__MX__get__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__get__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_get__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO () -mx_get__4 x = casadi__MX__get__4 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__get__5" c_casadi__MX__get__5 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () -casadi__MX__get__5 - :: MX -> MX -> Bool -> IMatrix -> IO () -casadi__MX__get__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__get__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_get__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () -mx_get__5 x = casadi__MX__get__5 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__get__6" c_casadi__MX__get__6 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () -casadi__MX__get__6 - :: MX -> MX -> Bool -> Slice -> IO () -casadi__MX__get__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__get__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_get__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO () -mx_get__6 x = casadi__MX__get__6 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getColind" c_casadi__MX__getColind - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) -casadi__MX__getColind - :: MX -> IO (Vector Int) -casadi__MX__getColind x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getColind errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getColind :: MXClass a => a -> IO (Vector Int) -mx_getColind x = casadi__MX__getColind (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getDep__0" c_casadi__MX__getDep__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__getDep__0 - :: MX -> IO MX -casadi__MX__getDep__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getDep__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getDep__0 :: MXClass a => a -> IO MX -mx_getDep__0 x = casadi__MX__getDep__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getDep__1" c_casadi__MX__getDep__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') -casadi__MX__getDep__1 - :: MX -> Int -> IO MX -casadi__MX__getDep__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getDep__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getDep__1 :: MXClass a => a -> Int -> IO MX -mx_getDep__1 x = casadi__MX__getDep__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getEqualityCheckingDepth" c_casadi__MX__getEqualityCheckingDepth - :: Ptr (Ptr StdString) -> IO CInt -casadi__MX__getEqualityCheckingDepth - :: IO Int -casadi__MX__getEqualityCheckingDepth = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getEqualityCheckingDepth errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getEqualityCheckingDepth :: IO Int -mx_getEqualityCheckingDepth = casadi__MX__getEqualityCheckingDepth - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getEvaluationOutput" c_casadi__MX__getEvaluationOutput - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__getEvaluationOutput - :: MX -> IO Int -casadi__MX__getEvaluationOutput x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getEvaluationOutput errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getEvaluationOutput :: MXClass a => a -> IO Int -mx_getEvaluationOutput x = casadi__MX__getEvaluationOutput (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getFunction" c_casadi__MX__getFunction - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Function') -casadi__MX__getFunction - :: MX -> IO Function -casadi__MX__getFunction x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getFunction errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getFunction :: MXClass a => a -> IO Function -mx_getFunction x = casadi__MX__getFunction (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getMatrixValue" c_casadi__MX__getMatrixValue - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr DMatrix') -casadi__MX__getMatrixValue - :: MX -> IO DMatrix -casadi__MX__getMatrixValue x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getMatrixValue errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getMatrixValue :: MXClass a => a -> IO DMatrix -mx_getMatrixValue x = casadi__MX__getMatrixValue (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getMaxNumCallsInPrint" c_casadi__MX__getMaxNumCallsInPrint - :: Ptr (Ptr StdString) -> IO CLong -casadi__MX__getMaxNumCallsInPrint - :: IO Int -casadi__MX__getMaxNumCallsInPrint = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getMaxNumCallsInPrint errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getMaxNumCallsInPrint :: IO Int -mx_getMaxNumCallsInPrint = casadi__MX__getMaxNumCallsInPrint - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getNZ__0" c_casadi__MX__getNZ__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () -casadi__MX__getNZ__0 - :: MX -> MX -> Bool -> IMatrix -> IO () -casadi__MX__getNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () -mx_getNZ__0 x = casadi__MX__getNZ__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getNZ__1" c_casadi__MX__getNZ__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () -casadi__MX__getNZ__1 - :: MX -> MX -> Bool -> Slice -> IO () -casadi__MX__getNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO () -mx_getNZ__1 x = casadi__MX__getNZ__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getName" c_casadi__MX__getName - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString) -casadi__MX__getName - :: MX -> IO String -casadi__MX__getName x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getName errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getName :: MXClass a => a -> IO String -mx_getName x = casadi__MX__getName (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getNdeps" c_casadi__MX__getNdeps - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__getNdeps - :: MX -> IO Int -casadi__MX__getNdeps x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getNdeps errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getNdeps :: MXClass a => a -> IO Int -mx_getNdeps x = casadi__MX__getNdeps (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getNumOutputs" c_casadi__MX__getNumOutputs - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__getNumOutputs - :: MX -> IO Int -casadi__MX__getNumOutputs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getNumOutputs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getNumOutputs :: MXClass a => a -> IO Int -mx_getNumOutputs x = casadi__MX__getNumOutputs (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getOp" c_casadi__MX__getOp - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__getOp - :: MX -> IO Int -casadi__MX__getOp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getOp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getOp :: MXClass a => a -> IO Int -mx_getOp x = casadi__MX__getOp (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getOutput__0" c_casadi__MX__getOutput__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__getOutput__0 - :: MX -> IO MX -casadi__MX__getOutput__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getOutput__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getOutput__0 :: MXClass a => a -> IO MX -mx_getOutput__0 x = casadi__MX__getOutput__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getOutput__1" c_casadi__MX__getOutput__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') -casadi__MX__getOutput__1 - :: MX -> Int -> IO MX -casadi__MX__getOutput__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getOutput__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getOutput__1 :: MXClass a => a -> Int -> IO MX -mx_getOutput__1 x = casadi__MX__getOutput__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getRow" c_casadi__MX__getRow - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) -casadi__MX__getRow - :: MX -> IO (Vector Int) -casadi__MX__getRow x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getRow errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getRow :: MXClass a => a -> IO (Vector Int) -mx_getRow x = casadi__MX__getRow (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getSparsity" c_casadi__MX__getSparsity - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity') -casadi__MX__getSparsity - :: MX -> IO Sparsity -casadi__MX__getSparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getSparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getSparsity :: MXClass a => a -> IO Sparsity -mx_getSparsity x = casadi__MX__getSparsity (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getTemp" c_casadi__MX__getTemp - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__getTemp - :: MX -> IO Int -casadi__MX__getTemp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getTemp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getTemp :: MXClass a => a -> IO Int -mx_getTemp x = casadi__MX__getTemp (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__getValue" c_casadi__MX__getValue - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CDouble -casadi__MX__getValue - :: MX -> IO Double -casadi__MX__getValue x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__getValue errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_getValue :: MXClass a => a -> IO Double -mx_getValue x = casadi__MX__getValue (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__inf__0" c_casadi__MX__inf__0 - :: Ptr (Ptr StdString) -> IO (Ptr MX') -casadi__MX__inf__0 - :: IO MX -casadi__MX__inf__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__inf__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_inf__0 :: IO MX -mx_inf__0 = casadi__MX__inf__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__inf__1" c_casadi__MX__inf__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') -casadi__MX__inf__1 - :: Int -> IO MX -casadi__MX__inf__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__inf__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_inf__1 :: Int -> IO MX -mx_inf__1 = casadi__MX__inf__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__inf__2" c_casadi__MX__inf__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__inf__2 - :: Int -> Int -> IO MX -casadi__MX__inf__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__inf__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_inf__2 :: Int -> Int -> IO MX -mx_inf__2 = casadi__MX__inf__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__inf__3" c_casadi__MX__inf__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__inf__3 - :: Sparsity -> IO MX -casadi__MX__inf__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__inf__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_inf__3 :: Sparsity -> IO MX -mx_inf__3 = casadi__MX__inf__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isBinary" c_casadi__MX__isBinary - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isBinary - :: MX -> IO Bool -casadi__MX__isBinary x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isBinary errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isBinary :: MXClass a => a -> IO Bool -mx_isBinary x = casadi__MX__isBinary (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isCommutative" c_casadi__MX__isCommutative - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isCommutative - :: MX -> IO Bool -casadi__MX__isCommutative x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isCommutative errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isCommutative :: MXClass a => a -> IO Bool -mx_isCommutative x = casadi__MX__isCommutative (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isConstant" c_casadi__MX__isConstant - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isConstant - :: MX -> IO Bool -casadi__MX__isConstant x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isConstant errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isConstant :: MXClass a => a -> IO Bool -mx_isConstant x = casadi__MX__isConstant (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isDense" c_casadi__MX__isDense - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isDense - :: MX -> IO Bool -casadi__MX__isDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isDense :: MXClass a => a -> IO Bool -mx_isDense x = casadi__MX__isDense (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isEmpty__0" c_casadi__MX__isEmpty__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isEmpty__0 - :: MX -> IO Bool -casadi__MX__isEmpty__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isEmpty__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isEmpty__0 :: MXClass a => a -> IO Bool -mx_isEmpty__0 x = casadi__MX__isEmpty__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isEmpty__1" c_casadi__MX__isEmpty__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__isEmpty__1 - :: MX -> Bool -> IO Bool -casadi__MX__isEmpty__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isEmpty__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isEmpty__1 :: MXClass a => a -> Bool -> IO Bool -mx_isEmpty__1 x = casadi__MX__isEmpty__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isEvaluation" c_casadi__MX__isEvaluation - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isEvaluation - :: MX -> IO Bool -casadi__MX__isEvaluation x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isEvaluation errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -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 (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isEvaluationOutput - :: MX -> IO Bool -casadi__MX__isEvaluationOutput x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isEvaluationOutput errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isEvaluationOutput :: MXClass a => a -> IO Bool -mx_isEvaluationOutput x = casadi__MX__isEvaluationOutput (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isIdentity" c_casadi__MX__isIdentity - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isIdentity - :: MX -> IO Bool -casadi__MX__isIdentity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isIdentity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isIdentity :: MXClass a => a -> IO Bool -mx_isIdentity x = casadi__MX__isIdentity (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isMinusOne" c_casadi__MX__isMinusOne - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isMinusOne - :: MX -> IO Bool -casadi__MX__isMinusOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isMinusOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isMinusOne :: MXClass a => a -> IO Bool -mx_isMinusOne x = casadi__MX__isMinusOne (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isMultiplication" c_casadi__MX__isMultiplication - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isMultiplication - :: MX -> IO Bool -casadi__MX__isMultiplication x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isMultiplication errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isMultiplication :: MXClass a => a -> IO Bool -mx_isMultiplication x = casadi__MX__isMultiplication (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isNorm" c_casadi__MX__isNorm - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isNorm - :: MX -> IO Bool -casadi__MX__isNorm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isNorm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isNorm :: MXClass a => a -> IO Bool -mx_isNorm x = casadi__MX__isNorm (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isOne" c_casadi__MX__isOne - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isOne - :: MX -> IO Bool -casadi__MX__isOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isOne :: MXClass a => a -> IO Bool -mx_isOne x = casadi__MX__isOne (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isOperation" c_casadi__MX__isOperation - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__isOperation - :: MX -> Int -> IO Bool -casadi__MX__isOperation x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isOperation errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isOperation :: MXClass a => a -> Int -> IO Bool -mx_isOperation x = casadi__MX__isOperation (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isRegular" c_casadi__MX__isRegular - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isRegular - :: MX -> IO Bool -casadi__MX__isRegular x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isRegular errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isRegular :: MXClass a => a -> IO Bool -mx_isRegular x = casadi__MX__isRegular (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isRowVector" c_casadi__MX__isRowVector - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isRowVector - :: MX -> IO Bool -casadi__MX__isRowVector x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isRowVector errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isRowVector :: MXClass a => a -> IO Bool -mx_isRowVector x = casadi__MX__isRowVector (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isScalar__0" c_casadi__MX__isScalar__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isScalar__0 - :: MX -> IO Bool -casadi__MX__isScalar__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isScalar__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isScalar__0 :: MXClass a => a -> IO Bool -mx_isScalar__0 x = casadi__MX__isScalar__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isScalar__1" c_casadi__MX__isScalar__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__isScalar__1 - :: MX -> Bool -> IO Bool -casadi__MX__isScalar__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isScalar__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isScalar__1 :: MXClass a => a -> Bool -> IO Bool -mx_isScalar__1 x = casadi__MX__isScalar__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isSquare" c_casadi__MX__isSquare - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isSquare - :: MX -> IO Bool -casadi__MX__isSquare x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isSquare errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isSquare :: MXClass a => a -> IO Bool -mx_isSquare x = casadi__MX__isSquare (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isSymbolic" c_casadi__MX__isSymbolic - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isSymbolic - :: MX -> IO Bool -casadi__MX__isSymbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isSymbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isSymbolic :: MXClass a => a -> IO Bool -mx_isSymbolic x = casadi__MX__isSymbolic (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isSymbolicSparse" c_casadi__MX__isSymbolicSparse - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isSymbolicSparse - :: MX -> IO Bool -casadi__MX__isSymbolicSparse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isSymbolicSparse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isSymbolicSparse :: MXClass a => a -> IO Bool -mx_isSymbolicSparse x = casadi__MX__isSymbolicSparse (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isTranspose" c_casadi__MX__isTranspose - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isTranspose - :: MX -> IO Bool -casadi__MX__isTranspose x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isTranspose errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isTranspose :: MXClass a => a -> IO Bool -mx_isTranspose x = casadi__MX__isTranspose (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isTril" c_casadi__MX__isTril - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isTril - :: MX -> IO Bool -casadi__MX__isTril x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isTril errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isTril :: MXClass a => a -> IO Bool -mx_isTril x = casadi__MX__isTril (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isTriu" c_casadi__MX__isTriu - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isTriu - :: MX -> IO Bool -casadi__MX__isTriu x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isTriu errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isTriu :: MXClass a => a -> IO Bool -mx_isTriu x = casadi__MX__isTriu (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isUnary" c_casadi__MX__isUnary - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isUnary - :: MX -> IO Bool -casadi__MX__isUnary x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isUnary errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isUnary :: MXClass a => a -> IO Bool -mx_isUnary x = casadi__MX__isUnary (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isVector__0" c_casadi__MX__isVector__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isVector__0 - :: MX -> IO Bool -casadi__MX__isVector__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isVector__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isVector__0 :: MXClass a => a -> IO Bool -mx_isVector__0 x = casadi__MX__isVector__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isVector__1" c_casadi__MX__isVector__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__isVector__1 - :: MX -> Bool -> IO Bool -casadi__MX__isVector__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isVector__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isVector__1 :: MXClass a => a -> Bool -> IO Bool -mx_isVector__1 x = casadi__MX__isVector__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__isZero" c_casadi__MX__isZero - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__isZero - :: MX -> IO Bool -casadi__MX__isZero x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__isZero errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_isZero :: MXClass a => a -> IO Bool -mx_isZero x = casadi__MX__isZero (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__lift" c_casadi__MX__lift - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () -casadi__MX__lift - :: MX -> MX -> IO () -casadi__MX__lift x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__lift errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_lift :: MXClass a => a -> MX -> IO () -mx_lift x = casadi__MX__lift (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__makeDense__0" c_casadi__MX__makeDense__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO () -casadi__MX__makeDense__0 - :: MX -> IO () -casadi__MX__makeDense__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__makeDense__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_makeDense__0 :: MXClass a => a -> IO () -mx_makeDense__0 x = casadi__MX__makeDense__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__makeDense__1" c_casadi__MX__makeDense__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () -casadi__MX__makeDense__1 - :: MX -> MX -> IO () -casadi__MX__makeDense__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__makeDense__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_makeDense__1 :: MXClass a => a -> MX -> IO () -mx_makeDense__1 x = casadi__MX__makeDense__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__mapping" c_casadi__MX__mapping - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr IMatrix') -casadi__MX__mapping - :: MX -> IO IMatrix -casadi__MX__mapping x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__mapping errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_mapping :: MXClass a => a -> IO IMatrix -mx_mapping x = casadi__MX__mapping (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__nan__0" c_casadi__MX__nan__0 - :: Ptr (Ptr StdString) -> IO (Ptr MX') -casadi__MX__nan__0 - :: IO MX -casadi__MX__nan__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__nan__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_nan__0 :: IO MX -mx_nan__0 = casadi__MX__nan__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__nan__1" c_casadi__MX__nan__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') -casadi__MX__nan__1 - :: Int -> IO MX -casadi__MX__nan__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__nan__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_nan__1 :: Int -> IO MX -mx_nan__1 = casadi__MX__nan__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__nan__2" c_casadi__MX__nan__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__nan__2 - :: Int -> Int -> IO MX -casadi__MX__nan__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__nan__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_nan__2 :: Int -> Int -> IO MX -mx_nan__2 = casadi__MX__nan__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__nan__3" c_casadi__MX__nan__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__nan__3 - :: Sparsity -> IO MX -casadi__MX__nan__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__nan__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_nan__3 :: Sparsity -> IO MX -mx_nan__3 = casadi__MX__nan__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__nnz" c_casadi__MX__nnz - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__nnz - :: MX -> IO Int -casadi__MX__nnz x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__nnz errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_nnz :: MXClass a => a -> IO Int -mx_nnz x = casadi__MX__nnz (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__numel__0" c_casadi__MX__numel__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__numel__0 - :: MX -> Int -> IO Int -casadi__MX__numel__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__numel__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_numel__0 :: MXClass a => a -> Int -> IO Int -mx_numel__0 x = casadi__MX__numel__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__numel__1" c_casadi__MX__numel__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__numel__1 - :: MX -> IO Int -casadi__MX__numel__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__numel__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_numel__1 :: MXClass a => a -> IO Int -mx_numel__1 x = casadi__MX__numel__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__ones__0" c_casadi__MX__ones__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__ones__0 - :: Sparsity -> IO MX -casadi__MX__ones__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__ones__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_ones__0 :: Sparsity -> IO MX -mx_ones__0 = casadi__MX__ones__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__ones__1" c_casadi__MX__ones__1 - :: Ptr (Ptr StdString) -> IO (Ptr MX') -casadi__MX__ones__1 - :: IO MX -casadi__MX__ones__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__ones__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_ones__1 :: IO MX -mx_ones__1 = casadi__MX__ones__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__ones__2" c_casadi__MX__ones__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') -casadi__MX__ones__2 - :: Int -> IO MX -casadi__MX__ones__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__ones__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_ones__2 :: Int -> IO MX -mx_ones__2 = casadi__MX__ones__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__ones__3" c_casadi__MX__ones__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__ones__3 - :: Int -> Int -> IO MX -casadi__MX__ones__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__ones__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_ones__3 :: Int -> Int -> IO MX -mx_ones__3 = casadi__MX__ones__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__operator_minus" c_casadi__MX__operator_minus - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__operator_minus - :: MX -> IO MX -casadi__MX__operator_minus x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__operator_minus errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__printme" c_casadi__MX__printme - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__printme errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__row" c_casadi__MX__row - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__row - :: MX -> Int -> IO Int -casadi__MX__row x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__row errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_row :: MXClass a => a -> Int -> IO Int -mx_row x = casadi__MX__row (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__set__0" c_casadi__MX__set__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__MX__set__0 - :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO () -casadi__MX__set__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__set__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_set__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO () -mx_set__0 x = casadi__MX__set__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__set__1" c_casadi__MX__set__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__MX__set__1 - :: MX -> MX -> Bool -> IMatrix -> Slice -> IO () -casadi__MX__set__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__set__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_set__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO () -mx_set__1 x = casadi__MX__set__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__set__2" c_casadi__MX__set__2 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__MX__set__2 - :: MX -> MX -> Bool -> Slice -> IMatrix -> IO () -casadi__MX__set__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__set__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_set__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO () -mx_set__2 x = casadi__MX__set__2 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__set__3" c_casadi__MX__set__3 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__MX__set__3 - :: MX -> MX -> Bool -> Slice -> Slice -> IO () -casadi__MX__set__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__set__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_set__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO () -mx_set__3 x = casadi__MX__set__3 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__set__4" c_casadi__MX__set__4 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO () -casadi__MX__set__4 - :: MX -> MX -> Bool -> Sparsity -> IO () -casadi__MX__set__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__set__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_set__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO () -mx_set__4 x = casadi__MX__set__4 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__set__5" c_casadi__MX__set__5 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () -casadi__MX__set__5 - :: MX -> MX -> Bool -> IMatrix -> IO () -casadi__MX__set__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__set__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_set__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () -mx_set__5 x = casadi__MX__set__5 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__set__6" c_casadi__MX__set__6 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () -casadi__MX__set__6 - :: MX -> MX -> Bool -> Slice -> IO () -casadi__MX__set__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__set__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_set__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO () -mx_set__6 x = casadi__MX__set__6 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__0" c_casadi__MX__setEqualityCheckingDepth__0 - :: Ptr (Ptr StdString) -> IO () -casadi__MX__setEqualityCheckingDepth__0 - :: IO () -casadi__MX__setEqualityCheckingDepth__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setEqualityCheckingDepth__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setEqualityCheckingDepth__0 :: IO () -mx_setEqualityCheckingDepth__0 = casadi__MX__setEqualityCheckingDepth__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__1" c_casadi__MX__setEqualityCheckingDepth__1 - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__MX__setEqualityCheckingDepth__1 - :: Int -> IO () -casadi__MX__setEqualityCheckingDepth__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setEqualityCheckingDepth__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setEqualityCheckingDepth__1 :: Int -> IO () -mx_setEqualityCheckingDepth__1 = casadi__MX__setEqualityCheckingDepth__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setMaxNumCallsInPrint__0" c_casadi__MX__setMaxNumCallsInPrint__0 - :: Ptr (Ptr StdString) -> IO () -casadi__MX__setMaxNumCallsInPrint__0 - :: IO () -casadi__MX__setMaxNumCallsInPrint__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setMaxNumCallsInPrint__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setMaxNumCallsInPrint__0 :: IO () -mx_setMaxNumCallsInPrint__0 = casadi__MX__setMaxNumCallsInPrint__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setMaxNumCallsInPrint__1" c_casadi__MX__setMaxNumCallsInPrint__1 - :: Ptr (Ptr StdString) -> CLong -> IO () -casadi__MX__setMaxNumCallsInPrint__1 - :: Int -> IO () -casadi__MX__setMaxNumCallsInPrint__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setMaxNumCallsInPrint__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setMaxNumCallsInPrint__1 :: Int -> IO () -mx_setMaxNumCallsInPrint__1 = casadi__MX__setMaxNumCallsInPrint__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setNZ__0" c_casadi__MX__setNZ__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () -casadi__MX__setNZ__0 - :: MX -> MX -> Bool -> IMatrix -> IO () -casadi__MX__setNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () -mx_setNZ__0 x = casadi__MX__setNZ__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setNZ__1" c_casadi__MX__setNZ__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () -casadi__MX__setNZ__1 - :: MX -> MX -> Bool -> Slice -> IO () -casadi__MX__setNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO () -mx_setNZ__1 x = casadi__MX__setNZ__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setSparse__0" c_casadi__MX__setSparse__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__setSparse__0 - :: MX -> Sparsity -> IO MX -casadi__MX__setSparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setSparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setSparse__0 :: MXClass a => a -> Sparsity -> IO MX -mx_setSparse__0 x = casadi__MX__setSparse__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setSparse__1" c_casadi__MX__setSparse__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX') -casadi__MX__setSparse__1 - :: MX -> Sparsity -> Bool -> IO MX -casadi__MX__setSparse__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setSparse__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setSparse__1 :: MXClass a => a -> Sparsity -> Bool -> IO MX -mx_setSparse__1 x = casadi__MX__setSparse__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__setTemp" c_casadi__MX__setTemp - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO () -casadi__MX__setTemp - :: MX -> Int -> IO () -casadi__MX__setTemp x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__setTemp errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_setTemp :: MXClass a => a -> Int -> IO () -mx_setTemp x = casadi__MX__setTemp (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__size__0" c_casadi__MX__size__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt -casadi__MX__size__0 - :: MX -> SparsityType -> IO Int -casadi__MX__size__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__size__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_size__0 :: MXClass a => a -> SparsityType -> IO Int -mx_size__0 x = casadi__MX__size__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__size__1" c_casadi__MX__size__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__size__1 - :: MX -> IO Int -casadi__MX__size__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__size__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_size__1 :: MXClass a => a -> IO Int -mx_size__1 x = casadi__MX__size__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__size1" c_casadi__MX__size1 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__size1 - :: MX -> IO Int -casadi__MX__size1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__size1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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 (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__size2 - :: MX -> IO Int -casadi__MX__size2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__size2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__sizeD" c_casadi__MX__sizeD - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__sizeD - :: MX -> IO Int -casadi__MX__sizeD x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sizeD errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sizeD :: MXClass a => a -> IO Int -mx_sizeD x = casadi__MX__sizeD (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sizeL" c_casadi__MX__sizeL - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__sizeL - :: MX -> IO Int -casadi__MX__sizeL x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sizeL errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sizeL :: MXClass a => a -> IO Int -mx_sizeL x = casadi__MX__sizeL (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sizeU" c_casadi__MX__sizeU - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__sizeU - :: MX -> IO Int -casadi__MX__sizeU x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sizeU errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sizeU :: MXClass a => a -> IO Int -mx_sizeU x = casadi__MX__sizeU (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sparse__0" c_casadi__MX__sparse__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__sparse__0 - :: Sparsity -> MX -> IO MX -casadi__MX__sparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sparse__0 :: Sparsity -> MX -> IO MX -mx_sparse__0 = casadi__MX__sparse__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sparse__1" c_casadi__MX__sparse__1 - :: Ptr (Ptr StdString) -> IO (Ptr MX') -casadi__MX__sparse__1 - :: IO MX -casadi__MX__sparse__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sparse__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sparse__1 :: IO MX -mx_sparse__1 = casadi__MX__sparse__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sparse__2" c_casadi__MX__sparse__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') -casadi__MX__sparse__2 - :: Int -> IO MX -casadi__MX__sparse__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sparse__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sparse__2 :: Int -> IO MX -mx_sparse__2 = casadi__MX__sparse__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sparse__3" c_casadi__MX__sparse__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__sparse__3 - :: Int -> Int -> IO MX -casadi__MX__sparse__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sparse__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sparse__3 :: Int -> Int -> IO MX -mx_sparse__3 = casadi__MX__sparse__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sparsity" c_casadi__MX__sparsity - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity') -casadi__MX__sparsity - :: MX -> IO Sparsity -casadi__MX__sparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sparsity :: MXClass a => a -> IO Sparsity -mx_sparsity x = casadi__MX__sparsity (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sparsityRef" c_casadi__MX__sparsityRef - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity') -casadi__MX__sparsityRef - :: MX -> IO Sparsity -casadi__MX__sparsityRef x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sparsityRef errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sparsityRef :: MXClass a => a -> IO Sparsity -mx_sparsityRef x = casadi__MX__sparsityRef (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__0" c_casadi__MX__sym__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -casadi__MX__sym__0 - :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX)) -casadi__MX__sym__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX)) -mx_sym__0 = casadi__MX__sym__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__1" c_casadi__MX__sym__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -casadi__MX__sym__1 - :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX)) -casadi__MX__sym__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX)) -mx_sym__1 = casadi__MX__sym__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__2" c_casadi__MX__sym__2 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__sym__2 - :: String -> Int -> Int -> Int -> IO (Vector MX) -casadi__MX__sym__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector MX) -mx_sym__2 = casadi__MX__sym__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__3" c_casadi__MX__sym__3 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__sym__3 - :: String -> Sparsity -> Int -> IO (Vector MX) -casadi__MX__sym__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__3 :: String -> Sparsity -> Int -> IO (Vector MX) -mx_sym__3 = casadi__MX__sym__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__4" c_casadi__MX__sym__4 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__sym__4 - :: String -> Sparsity -> IO MX -casadi__MX__sym__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__4 :: String -> Sparsity -> IO MX -mx_sym__4 = casadi__MX__sym__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__5" c_casadi__MX__sym__5 - :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr MX') -casadi__MX__sym__5 - :: String -> IO MX -casadi__MX__sym__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__5 :: String -> IO MX -mx_sym__5 = casadi__MX__sym__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__6" c_casadi__MX__sym__6 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr MX') -casadi__MX__sym__6 - :: String -> Int -> IO MX -casadi__MX__sym__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__6 :: String -> Int -> IO MX -mx_sym__6 = casadi__MX__sym__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__sym__7" c_casadi__MX__sym__7 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__sym__7 - :: String -> Int -> Int -> IO MX -casadi__MX__sym__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__sym__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_sym__7 :: String -> Int -> Int -> IO MX -mx_sym__7 = casadi__MX__sym__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__unary" c_casadi__MX__unary - :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> IO (Ptr MX') -casadi__MX__unary - :: Int -> MX -> IO MX -casadi__MX__unary x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__unary errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_unary :: Int -> MX -> IO MX -mx_unary = casadi__MX__unary - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zeros__0" c_casadi__MX__zeros__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__zeros__0 - :: Sparsity -> IO MX -casadi__MX__zeros__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zeros__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zeros__0 :: Sparsity -> IO MX -mx_zeros__0 = casadi__MX__zeros__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zeros__1" c_casadi__MX__zeros__1 - :: Ptr (Ptr StdString) -> IO (Ptr MX') -casadi__MX__zeros__1 - :: IO MX -casadi__MX__zeros__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zeros__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zeros__1 :: IO MX -mx_zeros__1 = casadi__MX__zeros__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zeros__2" c_casadi__MX__zeros__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') -casadi__MX__zeros__2 - :: Int -> IO MX -casadi__MX__zeros__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zeros__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zeros__2 :: Int -> IO MX -mx_zeros__2 = casadi__MX__zeros__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zeros__3" c_casadi__MX__zeros__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__zeros__3 - :: Int -> Int -> IO MX -casadi__MX__zeros__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zeros__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zeros__3 :: Int -> Int -> IO MX -mx_zeros__3 = casadi__MX__zeros__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_abs" c_casadi__MX__zz_abs - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_abs - :: MX -> IO MX -casadi__MX__zz_abs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_abs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_abs :: MXClass a => a -> IO MX -mx_zz_abs x = casadi__MX__zz_abs (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_acos" c_casadi__MX__zz_acos - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_acos - :: MX -> IO MX -casadi__MX__zz_acos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_acos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_acos :: MXClass a => a -> IO MX -mx_zz_acos x = casadi__MX__zz_acos (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_acosh" c_casadi__MX__zz_acosh - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_acosh - :: MX -> IO MX -casadi__MX__zz_acosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_acosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_acosh :: MXClass a => a -> IO MX -mx_zz_acosh x = casadi__MX__zz_acosh (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_and" c_casadi__MX__zz_and - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_and - :: MX -> MX -> IO MX -casadi__MX__zz_and x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_and errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_and :: MXClass a => a -> MX -> IO MX -mx_zz_and x = casadi__MX__zz_and (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_asin" c_casadi__MX__zz_asin - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_asin - :: MX -> IO MX -casadi__MX__zz_asin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_asin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_asin :: MXClass a => a -> IO MX -mx_zz_asin x = casadi__MX__zz_asin (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_asinh" c_casadi__MX__zz_asinh - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_asinh - :: MX -> IO MX -casadi__MX__zz_asinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_asinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_asinh :: MXClass a => a -> IO MX -mx_zz_asinh x = casadi__MX__zz_asinh (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_atan" c_casadi__MX__zz_atan - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_atan - :: MX -> IO MX -casadi__MX__zz_atan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_atan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_atan :: MXClass a => a -> IO MX -mx_zz_atan x = casadi__MX__zz_atan (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_atan2" c_casadi__MX__zz_atan2 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_atan2 - :: MX -> MX -> IO MX -casadi__MX__zz_atan2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_atan2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_atan2 :: MXClass a => a -> MX -> IO MX -mx_zz_atan2 x = casadi__MX__zz_atan2 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_atanh" c_casadi__MX__zz_atanh - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_atanh - :: MX -> IO MX -casadi__MX__zz_atanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_atanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_atanh :: MXClass a => a -> IO MX -mx_zz_atanh x = casadi__MX__zz_atanh (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_blockcat" c_casadi__MX__zz_blockcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr MX') -casadi__MX__zz_blockcat - :: Vector (Vector MX) -> IO MX -casadi__MX__zz_blockcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_blockcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_blockcat :: Vector (Vector MX) -> IO MX -mx_zz_blockcat = casadi__MX__zz_blockcat - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_blocksplit" c_casadi__MX__zz_blocksplit - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) -casadi__MX__zz_blocksplit - :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX)) -casadi__MX__zz_blocksplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_blocksplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_blocksplit :: MXClass a => a -> Vector Int -> Vector Int -> IO (Vector (Vector MX)) -mx_zz_blocksplit x = casadi__MX__zz_blocksplit (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_ceil" c_casadi__MX__zz_ceil - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_ceil - :: MX -> IO MX -casadi__MX__zz_ceil x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_ceil errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_ceil :: MXClass a => a -> IO MX -mx_zz_ceil x = casadi__MX__zz_ceil (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_cos" c_casadi__MX__zz_cos - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_cos - :: MX -> IO MX -casadi__MX__zz_cos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_cos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_cos :: MXClass a => a -> IO MX -mx_zz_cos x = casadi__MX__zz_cos (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_cosh" c_casadi__MX__zz_cosh - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_cosh - :: MX -> IO MX -casadi__MX__zz_cosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_cosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_cosh :: MXClass a => a -> IO MX -mx_zz_cosh x = casadi__MX__zz_cosh (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_countNodes" c_casadi__MX__zz_countNodes - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__zz_countNodes - :: MX -> IO Int -casadi__MX__zz_countNodes x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_countNodes errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_countNodes :: MXClass a => a -> IO Int -mx_zz_countNodes x = casadi__MX__zz_countNodes (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_createParent__0" c_casadi__MX__zz_createParent__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_createParent__0 - :: Vector MX -> Vector MX -> IO MX -casadi__MX__zz_createParent__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_createParent__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_createParent__0 :: Vector MX -> Vector MX -> IO MX -mx_zz_createParent__0 = casadi__MX__zz_createParent__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_createParent__1" c_casadi__MX__zz_createParent__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_createParent__1 - :: Vector Sparsity -> Vector MX -> IO MX -casadi__MX__zz_createParent__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_createParent__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_createParent__1 :: Vector Sparsity -> Vector MX -> IO MX -mx_zz_createParent__1 = casadi__MX__zz_createParent__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_createParent__2" c_casadi__MX__zz_createParent__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_createParent__2 - :: Vector MX -> IO MX -casadi__MX__zz_createParent__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_createParent__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_createParent__2 :: Vector MX -> IO MX -mx_zz_createParent__2 = casadi__MX__zz_createParent__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_cross__0" c_casadi__MX__zz_cross__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_cross__0 - :: MX -> MX -> IO MX -casadi__MX__zz_cross__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_cross__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_cross__0 :: MXClass a => a -> MX -> IO MX -mx_zz_cross__0 x = casadi__MX__zz_cross__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_cross__1" c_casadi__MX__zz_cross__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX') -casadi__MX__zz_cross__1 - :: MX -> MX -> Int -> IO MX -casadi__MX__zz_cross__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_cross__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_cross__1 :: MXClass a => a -> MX -> Int -> IO MX -mx_zz_cross__1 x = casadi__MX__zz_cross__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_densify" c_casadi__MX__zz_densify - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_densify - :: MX -> IO MX -casadi__MX__zz_densify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_densify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_densify :: MXClass a => a -> IO MX -mx_zz_densify x = casadi__MX__zz_densify (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_dependsOn" c_casadi__MX__zz_dependsOn - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO CInt -casadi__MX__zz_dependsOn - :: MX -> Vector MX -> IO Bool -casadi__MX__zz_dependsOn x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_dependsOn errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_dependsOn :: MXClass a => a -> Vector MX -> IO Bool -mx_zz_dependsOn x = casadi__MX__zz_dependsOn (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_det" c_casadi__MX__zz_det - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_det - :: MX -> IO MX -casadi__MX__zz_det x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_det errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_det :: MXClass a => a -> IO MX -mx_zz_det x = casadi__MX__zz_det (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_diag" c_casadi__MX__zz_diag - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_diag - :: MX -> IO MX -casadi__MX__zz_diag x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_diag errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_diag :: MXClass a => a -> IO MX -mx_zz_diag x = casadi__MX__zz_diag (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_diagcat" c_casadi__MX__zz_diagcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_diagcat - :: Vector MX -> IO MX -casadi__MX__zz_diagcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_diagcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_diagcat :: Vector MX -> IO MX -mx_zz_diagcat = casadi__MX__zz_diagcat - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_diagsplit" c_casadi__MX__zz_diagsplit - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_diagsplit - :: MX -> Vector Int -> Vector Int -> IO (Vector MX) -casadi__MX__zz_diagsplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_diagsplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_diagsplit :: MXClass a => a -> Vector Int -> Vector Int -> IO (Vector MX) -mx_zz_diagsplit x = casadi__MX__zz_diagsplit (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_eq" c_casadi__MX__zz_eq - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_eq - :: MX -> MX -> IO MX -casadi__MX__zz_eq x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_eq errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_eq :: MXClass a => a -> MX -> IO MX -mx_zz_eq x = casadi__MX__zz_eq (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_erf" c_casadi__MX__zz_erf - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_erf - :: MX -> IO MX -casadi__MX__zz_erf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_erf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_erf :: MXClass a => a -> IO MX -mx_zz_erf x = casadi__MX__zz_erf (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_erfinv" c_casadi__MX__zz_erfinv - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_erfinv - :: MX -> IO MX -casadi__MX__zz_erfinv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_erfinv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_erfinv :: MXClass a => a -> IO MX -mx_zz_erfinv x = casadi__MX__zz_erfinv (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_exp" c_casadi__MX__zz_exp - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_exp - :: MX -> IO MX -casadi__MX__zz_exp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_exp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_exp :: MXClass a => a -> IO MX -mx_zz_exp x = casadi__MX__zz_exp (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_extractShared__0" c_casadi__MX__zz_extractShared__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () -casadi__MX__zz_extractShared__0 - :: Vector MX -> Vector MX -> Vector MX -> IO () -casadi__MX__zz_extractShared__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_extractShared__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_extractShared__0 :: Vector MX -> Vector MX -> Vector MX -> IO () -mx_zz_extractShared__0 = casadi__MX__zz_extractShared__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_extractShared__1" c_casadi__MX__zz_extractShared__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO () -casadi__MX__zz_extractShared__1 - :: Vector MX -> Vector MX -> Vector MX -> String -> IO () -casadi__MX__zz_extractShared__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_extractShared__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_extractShared__1 :: Vector MX -> Vector MX -> Vector MX -> String -> IO () -mx_zz_extractShared__1 = casadi__MX__zz_extractShared__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_extractShared__2" c_casadi__MX__zz_extractShared__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO () -casadi__MX__zz_extractShared__2 - :: Vector MX -> Vector MX -> Vector MX -> String -> String -> IO () -casadi__MX__zz_extractShared__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_extractShared__2 :: Vector MX -> Vector MX -> Vector MX -> String -> String -> IO () -mx_zz_extractShared__2 = casadi__MX__zz_extractShared__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_floor" c_casadi__MX__zz_floor - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_floor - :: MX -> IO MX -casadi__MX__zz_floor x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_floor errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_floor :: MXClass a => a -> IO MX -mx_zz_floor x = casadi__MX__zz_floor (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_ge" c_casadi__MX__zz_ge - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_ge - :: MX -> MX -> IO MX -casadi__MX__zz_ge x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_ge errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_ge :: MXClass a => a -> MX -> IO MX -mx_zz_ge x = casadi__MX__zz_ge (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_getOperatorRepresentation" c_casadi__MX__zz_getOperatorRepresentation - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) -casadi__MX__zz_getOperatorRepresentation - :: MX -> Vector String -> IO String -casadi__MX__zz_getOperatorRepresentation x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_getOperatorRepresentation errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_getOperatorRepresentation :: MXClass a => a -> Vector String -> IO String -mx_zz_getOperatorRepresentation x = casadi__MX__zz_getOperatorRepresentation (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_getSymbols__0" c_casadi__MX__zz_getSymbols__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_getSymbols__0 - :: Vector MX -> IO (Vector MX) -casadi__MX__zz_getSymbols__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_getSymbols__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_getSymbols__0 :: Vector MX -> IO (Vector MX) -mx_zz_getSymbols__0 = casadi__MX__zz_getSymbols__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_getSymbols__1" c_casadi__MX__zz_getSymbols__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_getSymbols__1 - :: MX -> IO (Vector MX) -casadi__MX__zz_getSymbols__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_getSymbols__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_getSymbols__1 :: MXClass a => a -> IO (Vector MX) -mx_zz_getSymbols__1 x = casadi__MX__zz_getSymbols__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_gradient" c_casadi__MX__zz_gradient - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_gradient - :: MX -> MX -> IO MX -casadi__MX__zz_gradient x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_gradient errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_gradient :: MXClass a => a -> MX -> IO MX -mx_zz_gradient x = casadi__MX__zz_gradient (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_graph_substitute__0" c_casadi__MX__zz_graph_substitute__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_graph_substitute__0 - :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) -casadi__MX__zz_graph_substitute__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_graph_substitute__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_graph_substitute__0 :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) -mx_zz_graph_substitute__0 = casadi__MX__zz_graph_substitute__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_graph_substitute__1" c_casadi__MX__zz_graph_substitute__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_graph_substitute__1 - :: MX -> Vector MX -> Vector MX -> IO MX -casadi__MX__zz_graph_substitute__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_graph_substitute__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_graph_substitute__1 :: MXClass a => a -> Vector MX -> Vector MX -> IO MX -mx_zz_graph_substitute__1 x = casadi__MX__zz_graph_substitute__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_gt" c_casadi__MX__zz_gt - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_gt - :: MX -> MX -> IO MX -casadi__MX__zz_gt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_gt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_gt :: MXClass a => a -> MX -> IO MX -mx_zz_gt x = casadi__MX__zz_gt (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_hessian__0" c_casadi__MX__zz_hessian__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO () -casadi__MX__zz_hessian__0 - :: MX -> MX -> MX -> MX -> IO () -casadi__MX__zz_hessian__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_hessian__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_hessian__0 :: MXClass a => a -> MX -> MX -> MX -> IO () -mx_zz_hessian__0 x = casadi__MX__zz_hessian__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_hessian__1" c_casadi__MX__zz_hessian__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_hessian__1 - :: MX -> MX -> IO MX -casadi__MX__zz_hessian__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_hessian__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_hessian__1 :: MXClass a => a -> MX -> IO MX -mx_zz_hessian__1 x = casadi__MX__zz_hessian__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_horzcat" c_casadi__MX__zz_horzcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_horzcat - :: Vector MX -> IO MX -casadi__MX__zz_horzcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_horzcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_horzcat :: Vector MX -> IO MX -mx_zz_horzcat = casadi__MX__zz_horzcat - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_horzsplit" c_casadi__MX__zz_horzsplit - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_horzsplit - :: MX -> Vector Int -> IO (Vector MX) -casadi__MX__zz_horzsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_horzsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_horzsplit :: MXClass a => a -> Vector Int -> IO (Vector MX) -mx_zz_horzsplit x = casadi__MX__zz_horzsplit (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_if_else" c_casadi__MX__zz_if_else - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_if_else - :: MX -> MX -> MX -> IO MX -casadi__MX__zz_if_else x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_if_else errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_if_else :: MXClass a => a -> MX -> MX -> IO MX -mx_zz_if_else x = casadi__MX__zz_if_else (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_if_else_zero" c_casadi__MX__zz_if_else_zero - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_if_else_zero - :: MX -> MX -> IO MX -casadi__MX__zz_if_else_zero x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_if_else_zero errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_if_else_zero :: MXClass a => a -> MX -> IO MX -mx_zz_if_else_zero x = casadi__MX__zz_if_else_zero (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_inner_prod" c_casadi__MX__zz_inner_prod - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_inner_prod - :: MX -> MX -> IO MX -casadi__MX__zz_inner_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_inner_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_inner_prod :: MXClass a => a -> MX -> IO MX -mx_zz_inner_prod x = casadi__MX__zz_inner_prod (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_inv" c_casadi__MX__zz_inv - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_inv - :: MX -> IO MX -casadi__MX__zz_inv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_inv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_inv :: MXClass a => a -> IO MX -mx_zz_inv x = casadi__MX__zz_inv (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_isEqual__0" c_casadi__MX__zz_isEqual__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt -casadi__MX__zz_isEqual__0 - :: MX -> MX -> IO Bool -casadi__MX__zz_isEqual__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_isEqual__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_isEqual__0 :: MXClass a => a -> MX -> IO Bool -mx_zz_isEqual__0 x = casadi__MX__zz_isEqual__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_isEqual__1" c_casadi__MX__zz_isEqual__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO CInt -casadi__MX__zz_isEqual__1 - :: MX -> MX -> Int -> IO Bool -casadi__MX__zz_isEqual__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_isEqual__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_isEqual__1 :: MXClass a => a -> MX -> Int -> IO Bool -mx_zz_isEqual__1 x = casadi__MX__zz_isEqual__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_jacobian" c_casadi__MX__zz_jacobian - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_jacobian - :: MX -> MX -> IO MX -casadi__MX__zz_jacobian x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_jacobian errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_jacobian :: MXClass a => a -> MX -> IO MX -mx_zz_jacobian x = casadi__MX__zz_jacobian (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_kron" c_casadi__MX__zz_kron - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_kron - :: MX -> MX -> IO MX -casadi__MX__zz_kron x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_kron errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_kron :: MXClass a => a -> MX -> IO MX -mx_zz_kron x = casadi__MX__zz_kron (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_le" c_casadi__MX__zz_le - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_le - :: MX -> MX -> IO MX -casadi__MX__zz_le x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_le errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_le :: MXClass a => a -> MX -> IO MX -mx_zz_le x = casadi__MX__zz_le (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_linspace" c_casadi__MX__zz_linspace - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX') -casadi__MX__zz_linspace - :: MX -> MX -> Int -> IO MX -casadi__MX__zz_linspace x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_linspace errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_linspace :: MXClass a => a -> MX -> Int -> IO MX -mx_zz_linspace x = casadi__MX__zz_linspace (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_log" c_casadi__MX__zz_log - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_log - :: MX -> IO MX -casadi__MX__zz_log x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_log errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_log :: MXClass a => a -> IO MX -mx_zz_log x = casadi__MX__zz_log (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_log10" c_casadi__MX__zz_log10 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_log10 - :: MX -> IO MX -casadi__MX__zz_log10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_log10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_log10 :: MXClass a => a -> IO MX -mx_zz_log10 x = casadi__MX__zz_log10 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_lt" c_casadi__MX__zz_lt - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_lt - :: MX -> MX -> IO MX -casadi__MX__zz_lt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_lt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_lt :: MXClass a => a -> MX -> IO MX -mx_zz_lt x = casadi__MX__zz_lt (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_matrix_expand__0" c_casadi__MX__zz_matrix_expand__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_matrix_expand__0 - :: Vector MX -> IO (Vector MX) -casadi__MX__zz_matrix_expand__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_matrix_expand__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_matrix_expand__0 :: Vector MX -> IO (Vector MX) -mx_zz_matrix_expand__0 = casadi__MX__zz_matrix_expand__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_matrix_expand__1" c_casadi__MX__zz_matrix_expand__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_matrix_expand__1 - :: Vector MX -> Vector MX -> IO (Vector MX) -casadi__MX__zz_matrix_expand__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_matrix_expand__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_matrix_expand__1 :: Vector MX -> Vector MX -> IO (Vector MX) -mx_zz_matrix_expand__1 = casadi__MX__zz_matrix_expand__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_matrix_expand__2" c_casadi__MX__zz_matrix_expand__2 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_matrix_expand__2 - :: MX -> IO MX -casadi__MX__zz_matrix_expand__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_matrix_expand__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_matrix_expand__2 :: MX -> IO MX -mx_zz_matrix_expand__2 = casadi__MX__zz_matrix_expand__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_matrix_expand__3" c_casadi__MX__zz_matrix_expand__3 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_matrix_expand__3 - :: MX -> Vector MX -> IO MX -casadi__MX__zz_matrix_expand__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_matrix_expand__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_matrix_expand__3 :: MX -> Vector MX -> IO MX -mx_zz_matrix_expand__3 = casadi__MX__zz_matrix_expand__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_max" c_casadi__MX__zz_max - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_max - :: MX -> MX -> IO MX -casadi__MX__zz_max x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_max errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_max :: MXClass a => a -> MX -> IO MX -mx_zz_max x = casadi__MX__zz_max (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_min" c_casadi__MX__zz_min - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_min - :: MX -> MX -> IO MX -casadi__MX__zz_min x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_min errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_min :: MXClass a => a -> MX -> IO MX -mx_zz_min x = casadi__MX__zz_min (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_minus" c_casadi__MX__zz_minus - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_minus - :: MX -> MX -> IO MX -casadi__MX__zz_minus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_minus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_minus :: MXClass a => a -> MX -> IO MX -mx_zz_minus x = casadi__MX__zz_minus (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_mod" c_casadi__MX__zz_mod - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_mod - :: MX -> MX -> IO MX -casadi__MX__zz_mod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_mod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_mod :: MXClass a => a -> MX -> IO MX -mx_zz_mod x = casadi__MX__zz_mod (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_mpower" c_casadi__MX__zz_mpower - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_mpower - :: MX -> MX -> IO MX -casadi__MX__zz_mpower x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_mpower errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_mpower :: MXClass a => a -> MX -> IO MX -mx_zz_mpower x = casadi__MX__zz_mpower (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_mtimes__0" c_casadi__MX__zz_mtimes__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_mtimes__0 - :: MX -> MX -> MX -> IO MX -casadi__MX__zz_mtimes__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_mtimes__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_mtimes__0 :: MXClass a => a -> MX -> MX -> IO MX -mx_zz_mtimes__0 x = casadi__MX__zz_mtimes__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_mtimes__1" c_casadi__MX__zz_mtimes__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_mtimes__1 - :: MX -> MX -> IO MX -casadi__MX__zz_mtimes__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_mtimes__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_mtimes__1 :: MXClass a => a -> MX -> IO MX -mx_zz_mtimes__1 x = casadi__MX__zz_mtimes__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_ne" c_casadi__MX__zz_ne - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_ne - :: MX -> MX -> IO MX -casadi__MX__zz_ne x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_ne errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_ne :: MXClass a => a -> MX -> IO MX -mx_zz_ne x = casadi__MX__zz_ne (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_norm_0_mul" c_casadi__MX__zz_norm_0_mul - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt -casadi__MX__zz_norm_0_mul - :: MX -> MX -> IO Int -casadi__MX__zz_norm_0_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_norm_0_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_norm_0_mul :: MXClass a => a -> MX -> IO Int -mx_zz_norm_0_mul x = casadi__MX__zz_norm_0_mul (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_norm_1" c_casadi__MX__zz_norm_1 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_norm_1 - :: MX -> IO MX -casadi__MX__zz_norm_1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_norm_1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_norm_1 :: MXClass a => a -> IO MX -mx_zz_norm_1 x = casadi__MX__zz_norm_1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_norm_2" c_casadi__MX__zz_norm_2 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_norm_2 - :: MX -> IO MX -casadi__MX__zz_norm_2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_norm_2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_norm_2 :: MXClass a => a -> IO MX -mx_zz_norm_2 x = casadi__MX__zz_norm_2 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_norm_F" c_casadi__MX__zz_norm_F - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_norm_F - :: MX -> IO MX -casadi__MX__zz_norm_F x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_norm_F errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_norm_F :: MXClass a => a -> IO MX -mx_zz_norm_F x = casadi__MX__zz_norm_F (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_norm_inf" c_casadi__MX__zz_norm_inf - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_norm_inf - :: MX -> IO MX -casadi__MX__zz_norm_inf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_norm_inf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_norm_inf :: MXClass a => a -> IO MX -mx_zz_norm_inf x = casadi__MX__zz_norm_inf (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_not" c_casadi__MX__zz_not - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_not - :: MX -> IO MX -casadi__MX__zz_not x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_not errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_not :: MXClass a => a -> IO MX -mx_zz_not x = casadi__MX__zz_not (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_nullspace" c_casadi__MX__zz_nullspace - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_nullspace - :: MX -> IO MX -casadi__MX__zz_nullspace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_nullspace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_nullspace :: MXClass a => a -> IO MX -mx_zz_nullspace x = casadi__MX__zz_nullspace (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_or" c_casadi__MX__zz_or - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_or - :: MX -> MX -> IO MX -casadi__MX__zz_or x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_or errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_or :: MXClass a => a -> MX -> IO MX -mx_zz_or x = casadi__MX__zz_or (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_outer_prod" c_casadi__MX__zz_outer_prod - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_outer_prod - :: MX -> MX -> IO MX -casadi__MX__zz_outer_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_outer_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_outer_prod :: MXClass a => a -> MX -> IO MX -mx_zz_outer_prod x = casadi__MX__zz_outer_prod (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_pinv" c_casadi__MX__zz_pinv - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') -casadi__MX__zz_pinv - :: MX -> String -> IO MX -casadi__MX__zz_pinv x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_pinv errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_pinv :: MXClass a => a -> String -> IO MX -mx_zz_pinv x = casadi__MX__zz_pinv (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_plus" c_casadi__MX__zz_plus - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_plus - :: MX -> MX -> IO MX -casadi__MX__zz_plus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_plus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_plus :: MXClass a => a -> MX -> IO MX -mx_zz_plus x = casadi__MX__zz_plus (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_polyval" c_casadi__MX__zz_polyval - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_polyval - :: MX -> MX -> IO MX -casadi__MX__zz_polyval x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_polyval errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_polyval :: MXClass a => a -> MX -> IO MX -mx_zz_polyval x = casadi__MX__zz_polyval (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_power" c_casadi__MX__zz_power - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_power - :: MX -> MX -> IO MX -casadi__MX__zz_power x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_power errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_power :: MXClass a => a -> MX -> IO MX -mx_zz_power x = casadi__MX__zz_power (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_printCompact" c_casadi__MX__zz_printCompact - :: Ptr (Ptr StdString) -> Ptr MX' -> IO () -casadi__MX__zz_printCompact - :: MX -> IO () -casadi__MX__zz_printCompact x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_printCompact errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_printCompact :: MXClass a => a -> IO () -mx_zz_printCompact x = casadi__MX__zz_printCompact (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_quad_form__0" c_casadi__MX__zz_quad_form__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_quad_form__0 - :: MX -> IO MX -casadi__MX__zz_quad_form__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_quad_form__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_quad_form__0 :: MXClass a => a -> IO MX -mx_zz_quad_form__0 x = casadi__MX__zz_quad_form__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_quad_form__1" c_casadi__MX__zz_quad_form__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_quad_form__1 - :: MX -> MX -> IO MX -casadi__MX__zz_quad_form__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_quad_form__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_quad_form__1 :: MXClass a => a -> MX -> IO MX -mx_zz_quad_form__1 x = casadi__MX__zz_quad_form__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_rdivide" c_casadi__MX__zz_rdivide - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_rdivide - :: MX -> MX -> IO MX -casadi__MX__zz_rdivide x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_rdivide errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_rdivide :: MXClass a => a -> MX -> IO MX -mx_zz_rdivide x = casadi__MX__zz_rdivide (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_repmat__0" c_casadi__MX__zz_repmat__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') -casadi__MX__zz_repmat__0 - :: MX -> Int -> IO MX -casadi__MX__zz_repmat__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_repmat__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_repmat__0 :: MXClass a => a -> Int -> IO MX -mx_zz_repmat__0 x = casadi__MX__zz_repmat__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_repmat__1" c_casadi__MX__zz_repmat__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__zz_repmat__1 - :: MX -> Int -> Int -> IO MX -casadi__MX__zz_repmat__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_repmat__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_repmat__1 :: MXClass a => a -> Int -> Int -> IO MX -mx_zz_repmat__1 x = casadi__MX__zz_repmat__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_reshape__0" c_casadi__MX__zz_reshape__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') -casadi__MX__zz_reshape__0 - :: MX -> Sparsity -> IO MX -casadi__MX__zz_reshape__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_reshape__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_reshape__0 :: MXClass a => a -> Sparsity -> IO MX -mx_zz_reshape__0 x = casadi__MX__zz_reshape__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_reshape__1" c_casadi__MX__zz_reshape__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX') -casadi__MX__zz_reshape__1 - :: MX -> Int -> Int -> IO MX -casadi__MX__zz_reshape__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_reshape__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_reshape__1 :: MXClass a => a -> Int -> Int -> IO MX -mx_zz_reshape__1 x = casadi__MX__zz_reshape__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sign" c_casadi__MX__zz_sign - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sign - :: MX -> IO MX -casadi__MX__zz_sign x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sign errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sign :: MXClass a => a -> IO MX -mx_zz_sign x = casadi__MX__zz_sign (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_simplify" c_casadi__MX__zz_simplify - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_simplify - :: MX -> IO MX -casadi__MX__zz_simplify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_simplify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_simplify :: MXClass a => a -> IO MX -mx_zz_simplify x = casadi__MX__zz_simplify (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sin" c_casadi__MX__zz_sin - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sin - :: MX -> IO MX -casadi__MX__zz_sin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sin :: MXClass a => a -> IO MX -mx_zz_sin x = casadi__MX__zz_sin (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sinh" c_casadi__MX__zz_sinh - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sinh - :: MX -> IO MX -casadi__MX__zz_sinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sinh :: MXClass a => a -> IO MX -mx_zz_sinh x = casadi__MX__zz_sinh (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_solve" c_casadi__MX__zz_solve - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') -casadi__MX__zz_solve - :: MX -> MX -> String -> IO MX -casadi__MX__zz_solve x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_solve errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_solve :: MXClass a => a -> MX -> String -> IO MX -mx_zz_solve x = casadi__MX__zz_solve (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sprank" c_casadi__MX__zz_sprank - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -casadi__MX__zz_sprank - :: MX -> IO Int -casadi__MX__zz_sprank x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sprank errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sprank :: MXClass a => a -> IO Int -mx_zz_sprank x = casadi__MX__zz_sprank (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sqrt" c_casadi__MX__zz_sqrt - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sqrt - :: MX -> IO MX -casadi__MX__zz_sqrt x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sqrt errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sqrt :: MXClass a => a -> IO MX -mx_zz_sqrt x = casadi__MX__zz_sqrt (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_substitute__0" c_casadi__MX__zz_substitute__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_substitute__0 - :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) -casadi__MX__zz_substitute__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_substitute__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_substitute__0 :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) -mx_zz_substitute__0 = casadi__MX__zz_substitute__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_substitute__1" c_casadi__MX__zz_substitute__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_substitute__1 - :: MX -> MX -> MX -> IO MX -casadi__MX__zz_substitute__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_substitute__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_substitute__1 :: MXClass a => a -> MX -> MX -> IO MX -mx_zz_substitute__1 x = casadi__MX__zz_substitute__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_substituteInPlace__0" c_casadi__MX__zz_substituteInPlace__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () -casadi__MX__zz_substituteInPlace__0 - :: Vector MX -> Vector MX -> Vector MX -> IO () -casadi__MX__zz_substituteInPlace__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_substituteInPlace__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_substituteInPlace__0 :: Vector MX -> Vector MX -> Vector MX -> IO () -mx_zz_substituteInPlace__0 = casadi__MX__zz_substituteInPlace__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_substituteInPlace__1" c_casadi__MX__zz_substituteInPlace__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () -casadi__MX__zz_substituteInPlace__1 - :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO () -casadi__MX__zz_substituteInPlace__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_substituteInPlace__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_substituteInPlace__1 :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO () -mx_zz_substituteInPlace__1 = casadi__MX__zz_substituteInPlace__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_substituteInPlace__2" c_casadi__MX__zz_substituteInPlace__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () -casadi__MX__zz_substituteInPlace__2 - :: Vector MX -> Vector MX -> IO () -casadi__MX__zz_substituteInPlace__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_substituteInPlace__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_substituteInPlace__2 :: Vector MX -> Vector MX -> IO () -mx_zz_substituteInPlace__2 = casadi__MX__zz_substituteInPlace__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_substituteInPlace__3" c_casadi__MX__zz_substituteInPlace__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () -casadi__MX__zz_substituteInPlace__3 - :: Vector MX -> Vector MX -> Bool -> IO () -casadi__MX__zz_substituteInPlace__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_substituteInPlace__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_substituteInPlace__3 :: Vector MX -> Vector MX -> Bool -> IO () -mx_zz_substituteInPlace__3 = casadi__MX__zz_substituteInPlace__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sumAll" c_casadi__MX__zz_sumAll - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sumAll - :: MX -> IO MX -casadi__MX__zz_sumAll x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sumAll errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sumAll :: MXClass a => a -> IO MX -mx_zz_sumAll x = casadi__MX__zz_sumAll (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sumCols" c_casadi__MX__zz_sumCols - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sumCols - :: MX -> IO MX -casadi__MX__zz_sumCols x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sumCols errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sumCols :: MXClass a => a -> IO MX -mx_zz_sumCols x = casadi__MX__zz_sumCols (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sumRows" c_casadi__MX__zz_sumRows - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sumRows - :: MX -> IO MX -casadi__MX__zz_sumRows x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sumRows errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sumRows :: MXClass a => a -> IO MX -mx_zz_sumRows x = casadi__MX__zz_sumRows (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_sum_square" c_casadi__MX__zz_sum_square - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_sum_square - :: MX -> IO MX -casadi__MX__zz_sum_square x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_sum_square errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_sum_square :: MXClass a => a -> IO MX -mx_zz_sum_square x = casadi__MX__zz_sum_square (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_tan" c_casadi__MX__zz_tan - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_tan - :: MX -> IO MX -casadi__MX__zz_tan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_tan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_tan :: MXClass a => a -> IO MX -mx_zz_tan x = casadi__MX__zz_tan (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_tangent" c_casadi__MX__zz_tangent - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_tangent - :: MX -> MX -> IO MX -casadi__MX__zz_tangent x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_tangent errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_tangent :: MXClass a => a -> MX -> IO MX -mx_zz_tangent x = casadi__MX__zz_tangent (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_tanh" c_casadi__MX__zz_tanh - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_tanh - :: MX -> IO MX -casadi__MX__zz_tanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_tanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_tanh :: MXClass a => a -> IO MX -mx_zz_tanh x = casadi__MX__zz_tanh (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_times" c_casadi__MX__zz_times - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_times - :: MX -> MX -> IO MX -casadi__MX__zz_times x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_times errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_times :: MXClass a => a -> MX -> IO MX -mx_zz_times x = casadi__MX__zz_times (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_trace" c_casadi__MX__zz_trace - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_trace - :: MX -> IO MX -casadi__MX__zz_trace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_trace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_trace :: MXClass a => a -> IO MX -mx_zz_trace x = casadi__MX__zz_trace (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_tril__0" c_casadi__MX__zz_tril__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_tril__0 - :: MX -> IO MX -casadi__MX__zz_tril__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_tril__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_tril__0 :: MXClass a => a -> IO MX -mx_zz_tril__0 x = casadi__MX__zz_tril__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_tril__1" c_casadi__MX__zz_tril__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') -casadi__MX__zz_tril__1 - :: MX -> Bool -> IO MX -casadi__MX__zz_tril__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_tril__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_tril__1 :: MXClass a => a -> Bool -> IO MX -mx_zz_tril__1 x = casadi__MX__zz_tril__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_tril2symm" c_casadi__MX__zz_tril2symm - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_tril2symm - :: MX -> IO MX -casadi__MX__zz_tril2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_tril2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_tril2symm :: MXClass a => a -> IO MX -mx_zz_tril2symm x = casadi__MX__zz_tril2symm (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_triu__0" c_casadi__MX__zz_triu__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_triu__0 - :: MX -> IO MX -casadi__MX__zz_triu__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_triu__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_triu__0 :: MXClass a => a -> IO MX -mx_zz_triu__0 x = casadi__MX__zz_triu__0 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_triu__1" c_casadi__MX__zz_triu__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') -casadi__MX__zz_triu__1 - :: MX -> Bool -> IO MX -casadi__MX__zz_triu__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_triu__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_triu__1 :: MXClass a => a -> Bool -> IO MX -mx_zz_triu__1 x = casadi__MX__zz_triu__1 (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_triu2symm" c_casadi__MX__zz_triu2symm - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_triu2symm - :: MX -> IO MX -casadi__MX__zz_triu2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_triu2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_triu2symm :: MXClass a => a -> IO MX -mx_zz_triu2symm x = casadi__MX__zz_triu2symm (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_unite" c_casadi__MX__zz_unite - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_unite - :: MX -> MX -> IO MX -casadi__MX__zz_unite x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_unite errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_unite :: MXClass a => a -> MX -> IO MX -mx_zz_unite x = casadi__MX__zz_unite (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_vec" c_casadi__MX__zz_vec - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_vec - :: MX -> IO MX -casadi__MX__zz_vec x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_vec errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_vec :: MXClass a => a -> IO MX -mx_zz_vec x = casadi__MX__zz_vec (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_vecNZ" c_casadi__MX__zz_vecNZ - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -casadi__MX__zz_vecNZ - :: MX -> IO MX -casadi__MX__zz_vecNZ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_vecNZ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_vecNZ :: MXClass a => a -> IO MX -mx_zz_vecNZ x = casadi__MX__zz_vecNZ (castMX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_vecNZcat" c_casadi__MX__zz_vecNZcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_vecNZcat - :: Vector MX -> IO MX -casadi__MX__zz_vecNZcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_vecNZcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_vecNZcat :: Vector MX -> IO MX -mx_zz_vecNZcat = casadi__MX__zz_vecNZcat - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_veccat" c_casadi__MX__zz_veccat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_veccat - :: Vector MX -> IO MX -casadi__MX__zz_veccat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_veccat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_veccat :: Vector MX -> IO MX -mx_zz_veccat = casadi__MX__zz_veccat - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_vertcat" c_casadi__MX__zz_vertcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -casadi__MX__zz_vertcat - :: Vector MX -> IO MX -casadi__MX__zz_vertcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_vertcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_vertcat :: Vector MX -> IO MX -mx_zz_vertcat = casadi__MX__zz_vertcat - - --- direct wrapper -foreign import ccall unsafe "casadi__MX__zz_vertsplit" c_casadi__MX__zz_vertsplit - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX'))) -casadi__MX__zz_vertsplit - :: MX -> Vector Int -> IO (Vector MX) -casadi__MX__zz_vertsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MX__zz_vertsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mx_zz_vertsplit :: MXClass a => a -> Vector Int -> IO (Vector MX) -mx_zz_vertsplit x = casadi__MX__zz_vertsplit (castMX x) + mx___nonzero__, + mx_append, + mx_appendColumns, + mx_attachAssert__0, + mx_attachAssert__1, + mx_binary, + mx_colind, + mx_dimString, + mx_enlarge__0, + mx_enlarge__1, + mx_erase__0, + mx_erase__1, + mx_erase__2, + mx_erase__3, + mx_eye, + mx_find__0, + mx_find__1, + mx_getColind, + mx_getDep__0, + mx_getDep__1, + mx_getEqualityCheckingDepth, + mx_getEvaluationOutput, + mx_getFunction__0, + mx_getFunction__1, + mx_getMatrixValue, + mx_getNZ__0, + mx_getNZ__1, + mx_getName, + mx_getNdeps, + mx_getOp, + mx_getOutput__0, + mx_getOutput__1, + mx_getPrimitives, + mx_getRow, + mx_getSparsity, + mx_getTemp, + mx_getValue, + mx_get__0, + mx_get__1, + mx_get__2, + mx_get__3, + mx_get__4, + mx_get__5, + mx_get__6, + mx_hasDuplicates, + mx_inf__0, + mx_inf__1, + mx_inf__2, + mx_inf__3, + mx_inf__4, + mx_isBinary, + mx_isCommutative, + mx_isConstant, + mx_isEvaluation, + mx_isEvaluationOutput, + mx_isIdentity, + mx_isMinusOne, + mx_isMultiplication, + mx_isNorm, + mx_isOne, + mx_isOperation, + mx_isRegular, + mx_isSymbolic, + mx_isTranspose, + mx_isUnary, + mx_isValidInput, + mx_isZero, + mx_iscolumn, + mx_isdense, + mx_isempty__0, + mx_isempty__1, + mx_isrow, + mx_isscalar__0, + mx_isscalar__1, + mx_issquare, + mx_istril, + mx_istriu, + mx_isvector, + mx_joinPrimitives, + mx_lift, + mx_makeDense__0, + mx_makeDense__1, + mx_mapping, + mx_monitor, + mx_nOut, + mx_nan__0, + mx_nan__1, + mx_nan__2, + mx_nan__3, + mx_nan__4, + mx_nnz, + mx_numFunctions, + mx_numPrimitives, + mx_numel__0, + mx_numel__1, + mx_ones__0, + mx_ones__1, + mx_ones__2, + mx_ones__3, + mx_ones__4, + mx_operator_minus, + mx_printme, + mx_resetInput, + mx_row, + mx_setEqualityCheckingDepth__0, + mx_setEqualityCheckingDepth__1, + mx_setNZ__0, + mx_setNZ__1, + mx_setTemp, + mx_set__0, + mx_set__1, + mx_set__2, + mx_set__3, + mx_set__4, + mx_set__5, + mx_set__6, + mx_shape__0, + mx_shape__1, + mx_size, + mx_size1, + mx_size2, + mx_sizeD, + mx_sizeL, + mx_sizeU, + mx_sparse__0, + mx_sparse__1, + mx_sparse__2, + mx_sparse__3, + mx_sparse__4, + mx_sparsity, + mx_splitPrimitives, + mx_sym__0, + mx_sym__1, + mx_sym__2, + mx_sym__3, + mx_sym__4, + mx_sym__5, + mx_sym__6, + mx_sym__7, + mx_sym__8, + mx_unary, + mx_zeros__0, + mx_zeros__1, + mx_zeros__2, + mx_zeros__3, + mx_zeros__4, + mx_zz_project__0, + mx_zz_project__1, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__0" c_casadi__MX__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__0 + :: DMatrix -> IO MX +casadi__MX__CONSTRUCTOR__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__0 :: DMatrix -> IO MX +mx__0 = casadi__MX__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__1" c_casadi__MX__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__1 + :: Vector Double -> IO MX +casadi__MX__CONSTRUCTOR__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__1 :: Vector Double -> IO MX +mx__1 = casadi__MX__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__2" c_casadi__MX__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__2 + :: MX -> IO MX +casadi__MX__CONSTRUCTOR__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__2 :: MX -> IO MX +mx__2 = casadi__MX__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__3" c_casadi__MX__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__3 + :: Double -> IO MX +casadi__MX__CONSTRUCTOR__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__3 :: Double -> IO MX +mx__3 = casadi__MX__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__4" c_casadi__MX__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__4 + :: Sparsity -> MX -> IO MX +casadi__MX__CONSTRUCTOR__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__4 :: Sparsity -> MX -> IO MX +mx__4 = casadi__MX__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__5" c_casadi__MX__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__5 + :: Sparsity -> IO MX +casadi__MX__CONSTRUCTOR__5 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__5 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__5 :: Sparsity -> IO MX +mx__5 = casadi__MX__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__6" c_casadi__MX__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__6 + :: Int -> Int -> IO MX +casadi__MX__CONSTRUCTOR__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__6 :: Int -> Int -> IO MX +mx__6 = casadi__MX__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__7" c_casadi__MX__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> IO (Ptr MX') +casadi__MX__CONSTRUCTOR__7 + :: IO MX +casadi__MX__CONSTRUCTOR__7 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__CONSTRUCTOR__7 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx__7 :: IO MX +mx__7 = casadi__MX__CONSTRUCTOR__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__T" c_casadi__MX__T + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi__MX__T + :: MX -> IO MX +casadi__MX__T x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__T errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_T :: MXClass a => a -> IO MX +mx_T x = casadi__MX__T (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX____nonzero__" c_casadi__MX____nonzero__ + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX____nonzero__ + :: MX -> IO Bool +casadi__MX____nonzero__ x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX____nonzero__ errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx___nonzero__ :: MXClass a => a -> IO Bool +mx___nonzero__ x = casadi__MX____nonzero__ (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__append" c_casadi__MX__append + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () +casadi__MX__append + :: MX -> MX -> IO () +casadi__MX__append x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__append errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_append :: MXClass a => a -> MX -> IO () +mx_append x = casadi__MX__append (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__appendColumns" c_casadi__MX__appendColumns + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () +casadi__MX__appendColumns + :: MX -> MX -> IO () +casadi__MX__appendColumns x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__appendColumns errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_appendColumns :: MXClass a => a -> MX -> IO () +mx_appendColumns x = casadi__MX__appendColumns (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__attachAssert__0" c_casadi__MX__attachAssert__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi__MX__attachAssert__0 + :: MX -> MX -> IO MX +casadi__MX__attachAssert__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__attachAssert__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_attachAssert__0 :: MXClass a => a -> MX -> IO MX +mx_attachAssert__0 x = casadi__MX__attachAssert__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__attachAssert__1" c_casadi__MX__attachAssert__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') +casadi__MX__attachAssert__1 + :: MX -> MX -> String -> IO MX +casadi__MX__attachAssert__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__attachAssert__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_attachAssert__1 :: MXClass a => a -> MX -> String -> IO MX +mx_attachAssert__1 x = casadi__MX__attachAssert__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__binary" c_casadi__MX__binary + :: Ptr (Ptr StdString) -> 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' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__binary errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_binary :: Int -> MX -> MX -> IO MX +mx_binary = casadi__MX__binary + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__colind" c_casadi__MX__colind + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt +casadi__MX__colind + :: MX -> Int -> IO Int +casadi__MX__colind x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__colind errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_colind :: MXClass a => a -> Int -> IO Int +mx_colind x = casadi__MX__colind (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__dimString" c_casadi__MX__dimString + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString) +casadi__MX__dimString + :: MX -> IO String +casadi__MX__dimString x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__dimString errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_dimString :: MXClass a => a -> IO String +mx_dimString x = casadi__MX__dimString (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__enlarge__0" c_casadi__MX__enlarge__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__MX__enlarge__0 + :: MX -> Int -> Int -> Vector Int -> Vector Int -> IO () +casadi__MX__enlarge__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_enlarge__0 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () +mx_enlarge__0 x = casadi__MX__enlarge__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__enlarge__1" c_casadi__MX__enlarge__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__MX__enlarge__1 + :: MX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +casadi__MX__enlarge__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_enlarge__1 :: MXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +mx_enlarge__1 x = casadi__MX__enlarge__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__erase__0" c_casadi__MX__erase__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO () +casadi__MX__erase__0 + :: MX -> Vector Int -> IO () +casadi__MX__erase__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__erase__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_erase__0 :: MXClass a => a -> Vector Int -> IO () +mx_erase__0 x = casadi__MX__erase__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__erase__1" c_casadi__MX__erase__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__MX__erase__1 + :: MX -> Vector Int -> Bool -> IO () +casadi__MX__erase__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__erase__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_erase__1 :: MXClass a => a -> Vector Int -> Bool -> IO () +mx_erase__1 x = casadi__MX__erase__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__erase__2" c_casadi__MX__erase__2 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__MX__erase__2 + :: MX -> Vector Int -> Vector Int -> IO () +casadi__MX__erase__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__erase__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_erase__2 :: MXClass a => a -> Vector Int -> Vector Int -> IO () +mx_erase__2 x = casadi__MX__erase__2 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__erase__3" c_casadi__MX__erase__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__MX__erase__3 + :: MX -> Vector Int -> Vector Int -> Bool -> IO () +casadi__MX__erase__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__erase__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_erase__3 :: MXClass a => a -> Vector Int -> Vector Int -> Bool -> IO () +mx_erase__3 x = casadi__MX__erase__3 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__eye" c_casadi__MX__eye + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') +casadi__MX__eye + :: Int -> IO MX +casadi__MX__eye x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__eye errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_eye :: Int -> IO MX +mx_eye = casadi__MX__eye + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__find__0" c_casadi__MX__find__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) +casadi__MX__find__0 + :: MX -> IO (Vector Int) +casadi__MX__find__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__find__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_find__0 :: MXClass a => a -> IO (Vector Int) +mx_find__0 x = casadi__MX__find__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__find__1" c_casadi__MX__find__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec CInt)) +casadi__MX__find__1 + :: MX -> Bool -> IO (Vector Int) +casadi__MX__find__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__find__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_find__1 :: MXClass a => a -> Bool -> IO (Vector Int) +mx_find__1 x = casadi__MX__find__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__get__0" c_casadi__MX__get__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__MX__get__0 + :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO () +casadi__MX__get__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__get__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_get__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO () +mx_get__0 x = casadi__MX__get__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__get__1" c_casadi__MX__get__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__MX__get__1 + :: MX -> MX -> Bool -> IMatrix -> Slice -> IO () +casadi__MX__get__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__get__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_get__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO () +mx_get__1 x = casadi__MX__get__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__get__2" c_casadi__MX__get__2 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__MX__get__2 + :: MX -> MX -> Bool -> Slice -> IMatrix -> IO () +casadi__MX__get__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__get__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_get__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO () +mx_get__2 x = casadi__MX__get__2 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__get__3" c_casadi__MX__get__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__MX__get__3 + :: MX -> MX -> Bool -> Slice -> Slice -> IO () +casadi__MX__get__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__get__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_get__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO () +mx_get__3 x = casadi__MX__get__3 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__get__4" c_casadi__MX__get__4 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO () +casadi__MX__get__4 + :: MX -> MX -> Bool -> Sparsity -> IO () +casadi__MX__get__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__get__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_get__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO () +mx_get__4 x = casadi__MX__get__4 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__get__5" c_casadi__MX__get__5 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () +casadi__MX__get__5 + :: MX -> MX -> Bool -> IMatrix -> IO () +casadi__MX__get__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__get__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_get__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () +mx_get__5 x = casadi__MX__get__5 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__get__6" c_casadi__MX__get__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () +casadi__MX__get__6 + :: MX -> MX -> Bool -> Slice -> IO () +casadi__MX__get__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__get__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_get__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO () +mx_get__6 x = casadi__MX__get__6 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getColind" c_casadi__MX__getColind + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) +casadi__MX__getColind + :: MX -> IO (Vector Int) +casadi__MX__getColind x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getColind errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getColind :: MXClass a => a -> IO (Vector Int) +mx_getColind x = casadi__MX__getColind (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getDep__0" c_casadi__MX__getDep__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi__MX__getDep__0 + :: MX -> IO MX +casadi__MX__getDep__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getDep__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getDep__0 :: MXClass a => a -> IO MX +mx_getDep__0 x = casadi__MX__getDep__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getDep__1" c_casadi__MX__getDep__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi__MX__getDep__1 + :: MX -> Int -> IO MX +casadi__MX__getDep__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getDep__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getDep__1 :: MXClass a => a -> Int -> IO MX +mx_getDep__1 x = casadi__MX__getDep__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getEqualityCheckingDepth" c_casadi__MX__getEqualityCheckingDepth + :: Ptr (Ptr StdString) -> IO CInt +casadi__MX__getEqualityCheckingDepth + :: IO Int +casadi__MX__getEqualityCheckingDepth = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getEqualityCheckingDepth errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getEqualityCheckingDepth :: IO Int +mx_getEqualityCheckingDepth = casadi__MX__getEqualityCheckingDepth + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getEvaluationOutput" c_casadi__MX__getEvaluationOutput + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__getEvaluationOutput + :: MX -> IO Int +casadi__MX__getEvaluationOutput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getEvaluationOutput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getEvaluationOutput :: MXClass a => a -> IO Int +mx_getEvaluationOutput x = casadi__MX__getEvaluationOutput (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getFunction__0" c_casadi__MX__getFunction__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Function') +casadi__MX__getFunction__0 + :: MX -> IO Function +casadi__MX__getFunction__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getFunction__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getFunction__0 :: MXClass a => a -> IO Function +mx_getFunction__0 x = casadi__MX__getFunction__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getFunction__1" c_casadi__MX__getFunction__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr Function') +casadi__MX__getFunction__1 + :: MX -> Int -> IO Function +casadi__MX__getFunction__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getFunction__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getFunction__1 :: MXClass a => a -> Int -> IO Function +mx_getFunction__1 x = casadi__MX__getFunction__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getMatrixValue" c_casadi__MX__getMatrixValue + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr DMatrix') +casadi__MX__getMatrixValue + :: MX -> IO DMatrix +casadi__MX__getMatrixValue x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getMatrixValue errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getMatrixValue :: MXClass a => a -> IO DMatrix +mx_getMatrixValue x = casadi__MX__getMatrixValue (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getNZ__0" c_casadi__MX__getNZ__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () +casadi__MX__getNZ__0 + :: MX -> MX -> Bool -> IMatrix -> IO () +casadi__MX__getNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () +mx_getNZ__0 x = casadi__MX__getNZ__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getNZ__1" c_casadi__MX__getNZ__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () +casadi__MX__getNZ__1 + :: MX -> MX -> Bool -> Slice -> IO () +casadi__MX__getNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO () +mx_getNZ__1 x = casadi__MX__getNZ__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getName" c_casadi__MX__getName + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr StdString) +casadi__MX__getName + :: MX -> IO String +casadi__MX__getName x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getName errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getName :: MXClass a => a -> IO String +mx_getName x = casadi__MX__getName (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getNdeps" c_casadi__MX__getNdeps + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__getNdeps + :: MX -> IO Int +casadi__MX__getNdeps x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getNdeps errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getNdeps :: MXClass a => a -> IO Int +mx_getNdeps x = casadi__MX__getNdeps (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getOp" c_casadi__MX__getOp + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__getOp + :: MX -> IO Int +casadi__MX__getOp x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getOp errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getOp :: MXClass a => a -> IO Int +mx_getOp x = casadi__MX__getOp (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getOutput__0" c_casadi__MX__getOutput__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi__MX__getOutput__0 + :: MX -> IO MX +casadi__MX__getOutput__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getOutput__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getOutput__0 :: MXClass a => a -> IO MX +mx_getOutput__0 x = casadi__MX__getOutput__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getOutput__1" c_casadi__MX__getOutput__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi__MX__getOutput__1 + :: MX -> Int -> IO MX +casadi__MX__getOutput__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getOutput__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getOutput__1 :: MXClass a => a -> Int -> IO MX +mx_getOutput__1 x = casadi__MX__getOutput__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getPrimitives" c_casadi__MX__getPrimitives + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) +casadi__MX__getPrimitives + :: MX -> IO (Vector MX) +casadi__MX__getPrimitives x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getPrimitives errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getPrimitives :: MXClass a => a -> IO (Vector MX) +mx_getPrimitives x = casadi__MX__getPrimitives (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getRow" c_casadi__MX__getRow + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec CInt)) +casadi__MX__getRow + :: MX -> IO (Vector Int) +casadi__MX__getRow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getRow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getRow :: MXClass a => a -> IO (Vector Int) +mx_getRow x = casadi__MX__getRow (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getSparsity" c_casadi__MX__getSparsity + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity') +casadi__MX__getSparsity + :: MX -> IO Sparsity +casadi__MX__getSparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getSparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getSparsity :: MXClass a => a -> IO Sparsity +mx_getSparsity x = casadi__MX__getSparsity (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getTemp" c_casadi__MX__getTemp + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__getTemp + :: MX -> IO Int +casadi__MX__getTemp x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getTemp errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getTemp :: MXClass a => a -> IO Int +mx_getTemp x = casadi__MX__getTemp (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__getValue" c_casadi__MX__getValue + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CDouble +casadi__MX__getValue + :: MX -> IO Double +casadi__MX__getValue x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__getValue errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_getValue :: MXClass a => a -> IO Double +mx_getValue x = casadi__MX__getValue (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__hasDuplicates" c_casadi__MX__hasDuplicates + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__hasDuplicates + :: MX -> IO Bool +casadi__MX__hasDuplicates x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__hasDuplicates errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_hasDuplicates :: MXClass a => a -> IO Bool +mx_hasDuplicates x = casadi__MX__hasDuplicates (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__inf__0" c_casadi__MX__inf__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi__MX__inf__0 + :: (Int, Int) -> IO MX +casadi__MX__inf__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__inf__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_inf__0 :: (Int, Int) -> IO MX +mx_inf__0 = casadi__MX__inf__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__inf__1" c_casadi__MX__inf__1 + :: Ptr (Ptr StdString) -> IO (Ptr MX') +casadi__MX__inf__1 + :: IO MX +casadi__MX__inf__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__inf__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_inf__1 :: IO MX +mx_inf__1 = casadi__MX__inf__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__inf__2" c_casadi__MX__inf__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') +casadi__MX__inf__2 + :: Int -> IO MX +casadi__MX__inf__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__inf__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_inf__2 :: Int -> IO MX +mx_inf__2 = casadi__MX__inf__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__inf__3" c_casadi__MX__inf__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') +casadi__MX__inf__3 + :: Int -> Int -> IO MX +casadi__MX__inf__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__inf__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_inf__3 :: Int -> Int -> IO MX +mx_inf__3 = casadi__MX__inf__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__inf__4" c_casadi__MX__inf__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') +casadi__MX__inf__4 + :: Sparsity -> IO MX +casadi__MX__inf__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__inf__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_inf__4 :: Sparsity -> IO MX +mx_inf__4 = casadi__MX__inf__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isBinary" c_casadi__MX__isBinary + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isBinary + :: MX -> IO Bool +casadi__MX__isBinary x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isBinary errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isBinary :: MXClass a => a -> IO Bool +mx_isBinary x = casadi__MX__isBinary (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isCommutative" c_casadi__MX__isCommutative + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isCommutative + :: MX -> IO Bool +casadi__MX__isCommutative x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isCommutative errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isCommutative :: MXClass a => a -> IO Bool +mx_isCommutative x = casadi__MX__isCommutative (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isConstant" c_casadi__MX__isConstant + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isConstant + :: MX -> IO Bool +casadi__MX__isConstant x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isConstant errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +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 (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isEvaluation + :: MX -> IO Bool +casadi__MX__isEvaluation x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isEvaluation errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +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 (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isEvaluationOutput + :: MX -> IO Bool +casadi__MX__isEvaluationOutput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isEvaluationOutput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isEvaluationOutput :: MXClass a => a -> IO Bool +mx_isEvaluationOutput x = casadi__MX__isEvaluationOutput (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isIdentity" c_casadi__MX__isIdentity + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isIdentity + :: MX -> IO Bool +casadi__MX__isIdentity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isIdentity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isIdentity :: MXClass a => a -> IO Bool +mx_isIdentity x = casadi__MX__isIdentity (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isMinusOne" c_casadi__MX__isMinusOne + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isMinusOne + :: MX -> IO Bool +casadi__MX__isMinusOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isMinusOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isMinusOne :: MXClass a => a -> IO Bool +mx_isMinusOne x = casadi__MX__isMinusOne (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isMultiplication" c_casadi__MX__isMultiplication + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isMultiplication + :: MX -> IO Bool +casadi__MX__isMultiplication x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isMultiplication errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isMultiplication :: MXClass a => a -> IO Bool +mx_isMultiplication x = casadi__MX__isMultiplication (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isNorm" c_casadi__MX__isNorm + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isNorm + :: MX -> IO Bool +casadi__MX__isNorm x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isNorm errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isNorm :: MXClass a => a -> IO Bool +mx_isNorm x = casadi__MX__isNorm (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isOne" c_casadi__MX__isOne + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isOne + :: MX -> IO Bool +casadi__MX__isOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isOne :: MXClass a => a -> IO Bool +mx_isOne x = casadi__MX__isOne (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isOperation" c_casadi__MX__isOperation + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt +casadi__MX__isOperation + :: MX -> Int -> IO Bool +casadi__MX__isOperation x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isOperation errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isOperation :: MXClass a => a -> Int -> IO Bool +mx_isOperation x = casadi__MX__isOperation (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isRegular" c_casadi__MX__isRegular + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isRegular + :: MX -> IO Bool +casadi__MX__isRegular x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isRegular errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isRegular :: MXClass a => a -> IO Bool +mx_isRegular x = casadi__MX__isRegular (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isSymbolic" c_casadi__MX__isSymbolic + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isSymbolic + :: MX -> IO Bool +casadi__MX__isSymbolic x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isSymbolic errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isSymbolic :: MXClass a => a -> IO Bool +mx_isSymbolic x = casadi__MX__isSymbolic (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isTranspose" c_casadi__MX__isTranspose + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isTranspose + :: MX -> IO Bool +casadi__MX__isTranspose x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isTranspose errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isTranspose :: MXClass a => a -> IO Bool +mx_isTranspose x = casadi__MX__isTranspose (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isUnary" c_casadi__MX__isUnary + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isUnary + :: MX -> IO Bool +casadi__MX__isUnary x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isUnary errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isUnary :: MXClass a => a -> IO Bool +mx_isUnary x = casadi__MX__isUnary (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isValidInput" c_casadi__MX__isValidInput + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isValidInput + :: MX -> IO Bool +casadi__MX__isValidInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isValidInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isValidInput :: MXClass a => a -> IO Bool +mx_isValidInput x = casadi__MX__isValidInput (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isZero" c_casadi__MX__isZero + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isZero + :: MX -> IO Bool +casadi__MX__isZero x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isZero errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isZero :: MXClass a => a -> IO Bool +mx_isZero x = casadi__MX__isZero (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__iscolumn" c_casadi__MX__iscolumn + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__iscolumn + :: MX -> IO Bool +casadi__MX__iscolumn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__iscolumn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_iscolumn :: MXClass a => a -> IO Bool +mx_iscolumn x = casadi__MX__iscolumn (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isdense" c_casadi__MX__isdense + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isdense + :: MX -> IO Bool +casadi__MX__isdense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isdense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isdense :: MXClass a => a -> IO Bool +mx_isdense x = casadi__MX__isdense (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isempty__0" c_casadi__MX__isempty__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isempty__0 + :: MX -> IO Bool +casadi__MX__isempty__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isempty__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isempty__0 :: MXClass a => a -> IO Bool +mx_isempty__0 x = casadi__MX__isempty__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isempty__1" c_casadi__MX__isempty__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt +casadi__MX__isempty__1 + :: MX -> Bool -> IO Bool +casadi__MX__isempty__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isempty__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isempty__1 :: MXClass a => a -> Bool -> IO Bool +mx_isempty__1 x = casadi__MX__isempty__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isrow" c_casadi__MX__isrow + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isrow + :: MX -> IO Bool +casadi__MX__isrow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isrow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isrow :: MXClass a => a -> IO Bool +mx_isrow x = casadi__MX__isrow (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isscalar__0" c_casadi__MX__isscalar__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isscalar__0 + :: MX -> IO Bool +casadi__MX__isscalar__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isscalar__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isscalar__0 :: MXClass a => a -> IO Bool +mx_isscalar__0 x = casadi__MX__isscalar__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isscalar__1" c_casadi__MX__isscalar__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt +casadi__MX__isscalar__1 + :: MX -> Bool -> IO Bool +casadi__MX__isscalar__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isscalar__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isscalar__1 :: MXClass a => a -> Bool -> IO Bool +mx_isscalar__1 x = casadi__MX__isscalar__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__issquare" c_casadi__MX__issquare + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__issquare + :: MX -> IO Bool +casadi__MX__issquare x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__issquare errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_issquare :: MXClass a => a -> IO Bool +mx_issquare x = casadi__MX__issquare (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__istril" c_casadi__MX__istril + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__istril + :: MX -> IO Bool +casadi__MX__istril x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__istril errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_istril :: MXClass a => a -> IO Bool +mx_istril x = casadi__MX__istril (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__istriu" c_casadi__MX__istriu + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__istriu + :: MX -> IO Bool +casadi__MX__istriu x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__istriu errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_istriu :: MXClass a => a -> IO Bool +mx_istriu x = casadi__MX__istriu (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__isvector" c_casadi__MX__isvector + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__isvector + :: MX -> IO Bool +casadi__MX__isvector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__isvector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_isvector :: MXClass a => a -> IO Bool +mx_isvector x = casadi__MX__isvector (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__joinPrimitives" c_casadi__MX__joinPrimitives + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi__MX__joinPrimitives + :: MX -> Vector MX -> IO MX +casadi__MX__joinPrimitives x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__joinPrimitives errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_joinPrimitives :: MXClass a => a -> Vector MX -> IO MX +mx_joinPrimitives x = casadi__MX__joinPrimitives (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__lift" c_casadi__MX__lift + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () +casadi__MX__lift + :: MX -> MX -> IO () +casadi__MX__lift x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__lift errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_lift :: MXClass a => a -> MX -> IO () +mx_lift x = casadi__MX__lift (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__makeDense__0" c_casadi__MX__makeDense__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO () +casadi__MX__makeDense__0 + :: MX -> IO () +casadi__MX__makeDense__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__makeDense__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_makeDense__0 :: MXClass a => a -> IO () +mx_makeDense__0 x = casadi__MX__makeDense__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__makeDense__1" c_casadi__MX__makeDense__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO () +casadi__MX__makeDense__1 + :: MX -> MX -> IO () +casadi__MX__makeDense__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__makeDense__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_makeDense__1 :: MXClass a => a -> MX -> IO () +mx_makeDense__1 x = casadi__MX__makeDense__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__mapping" c_casadi__MX__mapping + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr IMatrix') +casadi__MX__mapping + :: MX -> IO IMatrix +casadi__MX__mapping x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__mapping errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_mapping :: MXClass a => a -> IO IMatrix +mx_mapping x = casadi__MX__mapping (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__monitor" c_casadi__MX__monitor + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') +casadi__MX__monitor + :: MX -> String -> IO MX +casadi__MX__monitor x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__monitor errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_monitor :: MXClass a => a -> String -> IO MX +mx_monitor x = casadi__MX__monitor (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__nOut" c_casadi__MX__nOut + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__nOut + :: MX -> IO Int +casadi__MX__nOut x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__nOut errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_nOut :: MXClass a => a -> IO Int +mx_nOut x = casadi__MX__nOut (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__nan__0" c_casadi__MX__nan__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi__MX__nan__0 + :: (Int, Int) -> IO MX +casadi__MX__nan__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__nan__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_nan__0 :: (Int, Int) -> IO MX +mx_nan__0 = casadi__MX__nan__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__nan__1" c_casadi__MX__nan__1 + :: Ptr (Ptr StdString) -> IO (Ptr MX') +casadi__MX__nan__1 + :: IO MX +casadi__MX__nan__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__nan__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_nan__1 :: IO MX +mx_nan__1 = casadi__MX__nan__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__nan__2" c_casadi__MX__nan__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') +casadi__MX__nan__2 + :: Int -> IO MX +casadi__MX__nan__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__nan__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_nan__2 :: Int -> IO MX +mx_nan__2 = casadi__MX__nan__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__nan__3" c_casadi__MX__nan__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') +casadi__MX__nan__3 + :: Int -> Int -> IO MX +casadi__MX__nan__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__nan__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_nan__3 :: Int -> Int -> IO MX +mx_nan__3 = casadi__MX__nan__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__nan__4" c_casadi__MX__nan__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') +casadi__MX__nan__4 + :: Sparsity -> IO MX +casadi__MX__nan__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__nan__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_nan__4 :: Sparsity -> IO MX +mx_nan__4 = casadi__MX__nan__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__nnz" c_casadi__MX__nnz + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__nnz + :: MX -> IO Int +casadi__MX__nnz x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__nnz errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_nnz :: MXClass a => a -> IO Int +mx_nnz x = casadi__MX__nnz (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__numFunctions" c_casadi__MX__numFunctions + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__numFunctions + :: MX -> IO Int +casadi__MX__numFunctions x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__numFunctions errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_numFunctions :: MXClass a => a -> IO Int +mx_numFunctions x = casadi__MX__numFunctions (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__numPrimitives" c_casadi__MX__numPrimitives + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__numPrimitives + :: MX -> IO Int +casadi__MX__numPrimitives x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__numPrimitives errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_numPrimitives :: MXClass a => a -> IO Int +mx_numPrimitives x = casadi__MX__numPrimitives (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__numel__0" c_casadi__MX__numel__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt +casadi__MX__numel__0 + :: MX -> Int -> IO Int +casadi__MX__numel__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__numel__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_numel__0 :: MXClass a => a -> Int -> IO Int +mx_numel__0 x = casadi__MX__numel__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__numel__1" c_casadi__MX__numel__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__numel__1 + :: MX -> IO Int +casadi__MX__numel__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__numel__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_numel__1 :: MXClass a => a -> IO Int +mx_numel__1 x = casadi__MX__numel__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__ones__0" c_casadi__MX__ones__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi__MX__ones__0 + :: (Int, Int) -> IO MX +casadi__MX__ones__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__ones__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_ones__0 :: (Int, Int) -> IO MX +mx_ones__0 = casadi__MX__ones__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__ones__1" c_casadi__MX__ones__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') +casadi__MX__ones__1 + :: Sparsity -> IO MX +casadi__MX__ones__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__ones__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_ones__1 :: Sparsity -> IO MX +mx_ones__1 = casadi__MX__ones__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__ones__2" c_casadi__MX__ones__2 + :: Ptr (Ptr StdString) -> IO (Ptr MX') +casadi__MX__ones__2 + :: IO MX +casadi__MX__ones__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__ones__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_ones__2 :: IO MX +mx_ones__2 = casadi__MX__ones__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__ones__3" c_casadi__MX__ones__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') +casadi__MX__ones__3 + :: Int -> IO MX +casadi__MX__ones__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__ones__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_ones__3 :: Int -> IO MX +mx_ones__3 = casadi__MX__ones__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__ones__4" c_casadi__MX__ones__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') +casadi__MX__ones__4 + :: Int -> Int -> IO MX +casadi__MX__ones__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__ones__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_ones__4 :: Int -> Int -> IO MX +mx_ones__4 = casadi__MX__ones__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__operator_minus" c_casadi__MX__operator_minus + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi__MX__operator_minus + :: MX -> IO MX +casadi__MX__operator_minus x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__operator_minus errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__printme" c_casadi__MX__printme + :: Ptr (Ptr StdString) -> 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' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__printme errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__resetInput" c_casadi__MX__resetInput + :: Ptr (Ptr StdString) -> Ptr MX' -> IO () +casadi__MX__resetInput + :: MX -> IO () +casadi__MX__resetInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__resetInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_resetInput :: MXClass a => a -> IO () +mx_resetInput x = casadi__MX__resetInput (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__row" c_casadi__MX__row + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt +casadi__MX__row + :: MX -> Int -> IO Int +casadi__MX__row x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__row errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_row :: MXClass a => a -> Int -> IO Int +mx_row x = casadi__MX__row (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__set__0" c_casadi__MX__set__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__MX__set__0 + :: MX -> MX -> Bool -> IMatrix -> IMatrix -> IO () +casadi__MX__set__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__set__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_set__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IMatrix -> IO () +mx_set__0 x = casadi__MX__set__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__set__1" c_casadi__MX__set__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__MX__set__1 + :: MX -> MX -> Bool -> IMatrix -> Slice -> IO () +casadi__MX__set__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__set__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_set__1 :: MXClass a => a -> MX -> Bool -> IMatrix -> Slice -> IO () +mx_set__1 x = casadi__MX__set__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__set__2" c_casadi__MX__set__2 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__MX__set__2 + :: MX -> MX -> Bool -> Slice -> IMatrix -> IO () +casadi__MX__set__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__set__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_set__2 :: MXClass a => a -> MX -> Bool -> Slice -> IMatrix -> IO () +mx_set__2 x = casadi__MX__set__2 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__set__3" c_casadi__MX__set__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__MX__set__3 + :: MX -> MX -> Bool -> Slice -> Slice -> IO () +casadi__MX__set__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__set__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_set__3 :: MXClass a => a -> MX -> Bool -> Slice -> Slice -> IO () +mx_set__3 x = casadi__MX__set__3 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__set__4" c_casadi__MX__set__4 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Sparsity' -> IO () +casadi__MX__set__4 + :: MX -> MX -> Bool -> Sparsity -> IO () +casadi__MX__set__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__set__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_set__4 :: MXClass a => a -> MX -> Bool -> Sparsity -> IO () +mx_set__4 x = casadi__MX__set__4 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__set__5" c_casadi__MX__set__5 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () +casadi__MX__set__5 + :: MX -> MX -> Bool -> IMatrix -> IO () +casadi__MX__set__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__set__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_set__5 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () +mx_set__5 x = casadi__MX__set__5 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__set__6" c_casadi__MX__set__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () +casadi__MX__set__6 + :: MX -> MX -> Bool -> Slice -> IO () +casadi__MX__set__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__set__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_set__6 :: MXClass a => a -> MX -> Bool -> Slice -> IO () +mx_set__6 x = casadi__MX__set__6 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__0" c_casadi__MX__setEqualityCheckingDepth__0 + :: Ptr (Ptr StdString) -> IO () +casadi__MX__setEqualityCheckingDepth__0 + :: IO () +casadi__MX__setEqualityCheckingDepth__0 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__setEqualityCheckingDepth__0 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_setEqualityCheckingDepth__0 :: IO () +mx_setEqualityCheckingDepth__0 = casadi__MX__setEqualityCheckingDepth__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__setEqualityCheckingDepth__1" c_casadi__MX__setEqualityCheckingDepth__1 + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__MX__setEqualityCheckingDepth__1 + :: Int -> IO () +casadi__MX__setEqualityCheckingDepth__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__setEqualityCheckingDepth__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_setEqualityCheckingDepth__1 :: Int -> IO () +mx_setEqualityCheckingDepth__1 = casadi__MX__setEqualityCheckingDepth__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__setNZ__0" c_casadi__MX__setNZ__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr IMatrix' -> IO () +casadi__MX__setNZ__0 + :: MX -> MX -> Bool -> IMatrix -> IO () +casadi__MX__setNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__setNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_setNZ__0 :: MXClass a => a -> MX -> Bool -> IMatrix -> IO () +mx_setNZ__0 x = casadi__MX__setNZ__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__setNZ__1" c_casadi__MX__setNZ__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> Ptr Slice' -> IO () +casadi__MX__setNZ__1 + :: MX -> MX -> Bool -> Slice -> IO () +casadi__MX__setNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__setNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_setNZ__1 :: MXClass a => a -> MX -> Bool -> Slice -> IO () +mx_setNZ__1 x = casadi__MX__setNZ__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__setTemp" c_casadi__MX__setTemp + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO () +casadi__MX__setTemp + :: MX -> Int -> IO () +casadi__MX__setTemp x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__setTemp errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_setTemp :: MXClass a => a -> Int -> IO () +mx_setTemp x = casadi__MX__setTemp (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__shape__0" c_casadi__MX__shape__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO CInt +casadi__MX__shape__0 + :: MX -> Int -> IO Int +casadi__MX__shape__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__shape__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_shape__0 :: MXClass a => a -> Int -> IO Int +mx_shape__0 x = casadi__MX__shape__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__shape__1" c_casadi__MX__shape__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdPair CInt CInt)) +casadi__MX__shape__1 + :: MX -> IO (Int, Int) +casadi__MX__shape__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__shape__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_shape__1 :: MXClass a => a -> IO (Int, Int) +mx_shape__1 x = casadi__MX__shape__1 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__size" c_casadi__MX__size + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__size + :: MX -> IO Int +casadi__MX__size x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__size errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__size1" c_casadi__MX__size1 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__size1 + :: MX -> IO Int +casadi__MX__size1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__size1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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 (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__size2 + :: MX -> IO Int +casadi__MX__size2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__size2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__sizeD" c_casadi__MX__sizeD + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__sizeD + :: MX -> IO Int +casadi__MX__sizeD x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sizeD errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sizeD :: MXClass a => a -> IO Int +mx_sizeD x = casadi__MX__sizeD (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sizeL" c_casadi__MX__sizeL + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__sizeL + :: MX -> IO Int +casadi__MX__sizeL x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sizeL errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sizeL :: MXClass a => a -> IO Int +mx_sizeL x = casadi__MX__sizeL (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sizeU" c_casadi__MX__sizeU + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi__MX__sizeU + :: MX -> IO Int +casadi__MX__sizeU x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sizeU errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sizeU :: MXClass a => a -> IO Int +mx_sizeU x = casadi__MX__sizeU (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sparse__0" c_casadi__MX__sparse__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr MX' -> IO (Ptr MX') +casadi__MX__sparse__0 + :: Sparsity -> MX -> IO MX +casadi__MX__sparse__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sparse__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sparse__0 :: Sparsity -> MX -> IO MX +mx_sparse__0 = casadi__MX__sparse__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sparse__1" c_casadi__MX__sparse__1 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi__MX__sparse__1 + :: (Int, Int) -> IO MX +casadi__MX__sparse__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sparse__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sparse__1 :: (Int, Int) -> IO MX +mx_sparse__1 = casadi__MX__sparse__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sparse__2" c_casadi__MX__sparse__2 + :: Ptr (Ptr StdString) -> IO (Ptr MX') +casadi__MX__sparse__2 + :: IO MX +casadi__MX__sparse__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sparse__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sparse__2 :: IO MX +mx_sparse__2 = casadi__MX__sparse__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sparse__3" c_casadi__MX__sparse__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') +casadi__MX__sparse__3 + :: Int -> IO MX +casadi__MX__sparse__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sparse__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sparse__3 :: Int -> IO MX +mx_sparse__3 = casadi__MX__sparse__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sparse__4" c_casadi__MX__sparse__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') +casadi__MX__sparse__4 + :: Int -> Int -> IO MX +casadi__MX__sparse__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sparse__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sparse__4 :: Int -> Int -> IO MX +mx_sparse__4 = casadi__MX__sparse__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sparsity" c_casadi__MX__sparsity + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr Sparsity') +casadi__MX__sparsity + :: MX -> IO Sparsity +casadi__MX__sparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sparsity :: MXClass a => a -> IO Sparsity +mx_sparsity x = casadi__MX__sparsity (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__splitPrimitives" c_casadi__MX__splitPrimitives + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) +casadi__MX__splitPrimitives + :: MX -> MX -> IO (Vector MX) +casadi__MX__splitPrimitives x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__splitPrimitives errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_splitPrimitives :: MXClass a => a -> MX -> IO (Vector MX) +mx_splitPrimitives x = casadi__MX__splitPrimitives (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__0" c_casadi__MX__sym__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi__MX__sym__0 + :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX)) +casadi__MX__sym__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector MX)) +mx_sym__0 = casadi__MX__sym__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__1" c_casadi__MX__sym__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi__MX__sym__1 + :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX)) +casadi__MX__sym__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector MX)) +mx_sym__1 = casadi__MX__sym__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__2" c_casadi__MX__sym__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi__MX__sym__2 + :: String -> Int -> Int -> Int -> IO (Vector MX) +casadi__MX__sym__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector MX) +mx_sym__2 = casadi__MX__sym__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__3" c_casadi__MX__sym__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi__MX__sym__3 + :: String -> Sparsity -> Int -> IO (Vector MX) +casadi__MX__sym__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__3 :: String -> Sparsity -> Int -> IO (Vector MX) +mx_sym__3 = casadi__MX__sym__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__4" c_casadi__MX__sym__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr MX') +casadi__MX__sym__4 + :: String -> Sparsity -> IO MX +casadi__MX__sym__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__4 :: String -> Sparsity -> IO MX +mx_sym__4 = casadi__MX__sym__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__5" c_casadi__MX__sym__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi__MX__sym__5 + :: String -> (Int, Int) -> IO MX +casadi__MX__sym__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__5 :: String -> (Int, Int) -> IO MX +mx_sym__5 = casadi__MX__sym__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__6" c_casadi__MX__sym__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr MX') +casadi__MX__sym__6 + :: String -> IO MX +casadi__MX__sym__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__6 :: String -> IO MX +mx_sym__6 = casadi__MX__sym__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__7" c_casadi__MX__sym__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr MX') +casadi__MX__sym__7 + :: String -> Int -> IO MX +casadi__MX__sym__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__7 :: String -> Int -> IO MX +mx_sym__7 = casadi__MX__sym__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__sym__8" c_casadi__MX__sym__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr MX') +casadi__MX__sym__8 + :: String -> Int -> Int -> IO MX +casadi__MX__sym__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__sym__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_sym__8 :: String -> Int -> Int -> IO MX +mx_sym__8 = casadi__MX__sym__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__unary" c_casadi__MX__unary + :: Ptr (Ptr StdString) -> CInt -> Ptr MX' -> IO (Ptr MX') +casadi__MX__unary + :: Int -> MX -> IO MX +casadi__MX__unary x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__unary errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_unary :: Int -> MX -> IO MX +mx_unary = casadi__MX__unary + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__zeros__0" c_casadi__MX__zeros__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi__MX__zeros__0 + :: (Int, Int) -> IO MX +casadi__MX__zeros__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__zeros__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_zeros__0 :: (Int, Int) -> IO MX +mx_zeros__0 = casadi__MX__zeros__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__zeros__1" c_casadi__MX__zeros__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr MX') +casadi__MX__zeros__1 + :: Sparsity -> IO MX +casadi__MX__zeros__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__zeros__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_zeros__1 :: Sparsity -> IO MX +mx_zeros__1 = casadi__MX__zeros__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__zeros__2" c_casadi__MX__zeros__2 + :: Ptr (Ptr StdString) -> IO (Ptr MX') +casadi__MX__zeros__2 + :: IO MX +casadi__MX__zeros__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__zeros__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_zeros__2 :: IO MX +mx_zeros__2 = casadi__MX__zeros__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__zeros__3" c_casadi__MX__zeros__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr MX') +casadi__MX__zeros__3 + :: Int -> IO MX +casadi__MX__zeros__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__zeros__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_zeros__3 :: Int -> IO MX +mx_zeros__3 = casadi__MX__zeros__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__zeros__4" c_casadi__MX__zeros__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr MX') +casadi__MX__zeros__4 + :: Int -> Int -> IO MX +casadi__MX__zeros__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__zeros__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_zeros__4 :: Int -> Int -> IO MX +mx_zeros__4 = casadi__MX__zeros__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__zz_project__0" c_casadi__MX__zz_project__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') +casadi__MX__zz_project__0 + :: MX -> Sparsity -> IO MX +casadi__MX__zz_project__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__zz_project__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_zz_project__0 :: MXClass a => a -> Sparsity -> IO MX +mx_zz_project__0 x = casadi__MX__zz_project__0 (castMX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__MX__zz_project__1" c_casadi__MX__zz_project__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX') +casadi__MX__zz_project__1 + :: MX -> Sparsity -> Bool -> IO MX +casadi__MX__zz_project__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MX__zz_project__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mx_zz_project__1 :: MXClass a => a -> Sparsity -> Bool -> IO MX +mx_zz_project__1 x = casadi__MX__zz_project__1 (castMX x) diff --git a/Casadi/Core/Classes/MXAlgEl.hs b/Casadi/Core/Classes/MXAlgEl.hs deleted file mode 100644 --- a/Casadi/Core/Classes/MXAlgEl.hs +++ /dev/null @@ -1,31 +0,0 @@ -{-# OPTIONS_GHC -Wall #-} -{-# OPTIONS_GHC -fno-warn-unused-imports #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# Language ForeignFunctionInterface #-} -{-# Language FlexibleInstances #-} -{-# Language MultiParamTypeClasses #-} - -module Casadi.Core.Classes.MXAlgEl - ( - MXAlgEl, - MXAlgElClass(..), - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums diff --git a/Casadi/Core/Classes/MXFunction.hs b/Casadi/Core/Classes/MXFunction.hs --- a/Casadi/Core/Classes/MXFunction.hs +++ b/Casadi/Core/Classes/MXFunction.hs @@ -12,13 +12,18 @@ mxFunction__0, mxFunction__1, mxFunction__2, + mxFunction__3, + mxFunction__4, + mxFunction__5, + mxFunction__6, + mxFunction__7, + mxFunction__8, + mxFunction__9, mxFunction_countNodes, mxFunction_expand__0, mxFunction_expand__1, mxFunction_generateLiftingFunctions, - mxFunction_getAlgorithmSize, mxFunction_getFree, - mxFunction_getWorkSize, mxFunction_grad__0, mxFunction_grad__1, mxFunction_grad__2, @@ -60,6 +65,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -67,72 +73,230 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__0" c_casadi__MXFunction__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MXFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr MXFunction') casadi__MXFunction__CONSTRUCTOR__0 - :: Vector MX -> Vector MX -> IO MXFunction -casadi__MXFunction__CONSTRUCTOR__0 x0 x1 = + :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__MXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__MXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -mxFunction__0 :: Vector MX -> Vector MX -> IO MXFunction +mxFunction__0 :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> IO MXFunction mxFunction__0 = casadi__MXFunction__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__1" c_casadi__MXFunction__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction') casadi__MXFunction__CONSTRUCTOR__1 - :: Function -> IO MXFunction -casadi__MXFunction__CONSTRUCTOR__1 x0 = + :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__MXFunction__CONSTRUCTOR__1 errStrPtrP x0' + ret <- c_casadi__MXFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -mxFunction__1 :: Function -> IO MXFunction +mxFunction__1 :: String -> (M.Map String MX, Vector String) -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction mxFunction__1 = casadi__MXFunction__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__2" c_casadi__MXFunction__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> IO (Ptr MXFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr MXFunction') casadi__MXFunction__CONSTRUCTOR__2 + :: String -> Vector MX -> (M.Map String MX, Vector String) -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MXFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mxFunction__2 :: String -> Vector MX -> (M.Map String MX, Vector String) -> IO MXFunction +mxFunction__2 = casadi__MXFunction__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__3" c_casadi__MXFunction__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction') +casadi__MXFunction__CONSTRUCTOR__3 + :: String -> Vector MX -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MXFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mxFunction__3 :: String -> Vector MX -> (M.Map String MX, Vector String) -> M.Map String GenericType -> IO MXFunction +mxFunction__3 = casadi__MXFunction__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__4" c_casadi__MXFunction__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MXFunction') +casadi__MXFunction__CONSTRUCTOR__4 + :: String -> (M.Map String MX, Vector String) -> Vector MX -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MXFunction__CONSTRUCTOR__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mxFunction__4 :: String -> (M.Map String MX, Vector String) -> Vector MX -> IO MXFunction +mxFunction__4 = casadi__MXFunction__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__5" c_casadi__MXFunction__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction') +casadi__MXFunction__CONSTRUCTOR__5 + :: String -> (M.Map String MX, Vector String) -> Vector MX -> M.Map String GenericType -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MXFunction__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mxFunction__5 :: String -> (M.Map String MX, Vector String) -> Vector MX -> M.Map String GenericType -> IO MXFunction +mxFunction__5 = casadi__MXFunction__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__6" c_casadi__MXFunction__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MXFunction') +casadi__MXFunction__CONSTRUCTOR__6 + :: String -> Vector MX -> Vector MX -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MXFunction__CONSTRUCTOR__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mxFunction__6 :: String -> Vector MX -> Vector MX -> IO MXFunction +mxFunction__6 = casadi__MXFunction__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__7" c_casadi__MXFunction__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction') +casadi__MXFunction__CONSTRUCTOR__7 + :: String -> Vector MX -> Vector MX -> M.Map String GenericType -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MXFunction__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mxFunction__7 :: String -> Vector MX -> Vector MX -> M.Map String GenericType -> IO MXFunction +mxFunction__7 = casadi__MXFunction__CONSTRUCTOR__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__8" c_casadi__MXFunction__CONSTRUCTOR__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') +casadi__MXFunction__CONSTRUCTOR__8 + :: Function -> IO MXFunction +casadi__MXFunction__CONSTRUCTOR__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MXFunction__CONSTRUCTOR__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mxFunction__8 :: Function -> IO MXFunction +mxFunction__8 = casadi__MXFunction__CONSTRUCTOR__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MXFunction__CONSTRUCTOR__9" c_casadi__MXFunction__CONSTRUCTOR__9 + :: Ptr (Ptr StdString) -> IO (Ptr MXFunction') +casadi__MXFunction__CONSTRUCTOR__9 :: IO MXFunction -casadi__MXFunction__CONSTRUCTOR__2 = +casadi__MXFunction__CONSTRUCTOR__9 = do errStrPtrP <- new nullPtr - ret <- c_casadi__MXFunction__CONSTRUCTOR__2 errStrPtrP + ret <- c_casadi__MXFunction__CONSTRUCTOR__9 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -mxFunction__2 :: IO MXFunction -mxFunction__2 = casadi__MXFunction__CONSTRUCTOR__2 +mxFunction__9 :: IO MXFunction +mxFunction__9 = casadi__MXFunction__CONSTRUCTOR__9 -- direct wrapper @@ -219,26 +383,6 @@ -- direct wrapper -foreign import ccall unsafe "casadi__MXFunction__getAlgorithmSize" c_casadi__MXFunction__getAlgorithmSize - :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO CInt -casadi__MXFunction__getAlgorithmSize - :: MXFunction -> IO Int -casadi__MXFunction__getAlgorithmSize x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MXFunction__getAlgorithmSize errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mxFunction_getAlgorithmSize :: MXFunctionClass a => a -> IO Int -mxFunction_getAlgorithmSize x = casadi__MXFunction__getAlgorithmSize (castMXFunction x) - - --- direct wrapper foreign import ccall unsafe "casadi__MXFunction__getFree" c_casadi__MXFunction__getFree :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr (StdVec (Ptr MX'))) casadi__MXFunction__getFree @@ -256,26 +400,6 @@ -- classy wrapper mxFunction_getFree :: MXFunctionClass a => a -> IO (Vector MX) mxFunction_getFree x = casadi__MXFunction__getFree (castMXFunction x) - - --- direct wrapper -foreign import ccall unsafe "casadi__MXFunction__getWorkSize" c_casadi__MXFunction__getWorkSize - :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO CInt -casadi__MXFunction__getWorkSize - :: MXFunction -> IO Int -casadi__MXFunction__getWorkSize x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__MXFunction__getWorkSize errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -mxFunction_getWorkSize :: MXFunctionClass a => a -> IO Int -mxFunction_getWorkSize x = casadi__MXFunction__getWorkSize (castMXFunction x) -- direct wrapper diff --git a/Casadi/Core/Classes/Map.hs b/Casadi/Core/Classes/Map.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/Map.hs @@ -0,0 +1,102 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.Map + ( + Map, + MapClass(..), + map__0, + map__1, + map__2, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__Map__CONSTRUCTOR__0" c_casadi__Map__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Map') +casadi__Map__CONSTRUCTOR__0 + :: String -> Function -> Int -> Vector Bool -> Vector Bool -> IO Map +casadi__Map__CONSTRUCTOR__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Map__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +map__0 :: String -> Function -> Int -> Vector Bool -> Vector Bool -> IO Map +map__0 = casadi__Map__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Map__CONSTRUCTOR__1" c_casadi__Map__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Map') +casadi__Map__CONSTRUCTOR__1 + :: String -> Function -> Int -> Vector Bool -> Vector Bool -> M.Map String GenericType -> IO Map +casadi__Map__CONSTRUCTOR__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Map__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +map__1 :: String -> Function -> Int -> Vector Bool -> Vector Bool -> M.Map String GenericType -> IO Map +map__1 = casadi__Map__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Map__CONSTRUCTOR__2" c_casadi__Map__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> IO (Ptr Map') +casadi__Map__CONSTRUCTOR__2 + :: IO Map +casadi__Map__CONSTRUCTOR__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Map__CONSTRUCTOR__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +map__2 :: IO Map +map__2 = casadi__Map__CONSTRUCTOR__2 + diff --git a/Casadi/Core/Classes/MapAccum.hs b/Casadi/Core/Classes/MapAccum.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/MapAccum.hs @@ -0,0 +1,129 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.MapAccum + ( + MapAccum, + MapAccumClass(..), + mapAccum__0, + mapAccum__1, + mapAccum__2, + mapAccum__3, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__0" c_casadi__MapAccum__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr MapAccum') +casadi__MapAccum__CONSTRUCTOR__0 + :: String -> Function -> Int -> Vector Bool -> Vector Int -> IO MapAccum +casadi__MapAccum__CONSTRUCTOR__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MapAccum__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mapAccum__0 :: String -> Function -> Int -> Vector Bool -> Vector Int -> IO MapAccum +mapAccum__0 = casadi__MapAccum__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__1" c_casadi__MapAccum__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr MapAccum') +casadi__MapAccum__CONSTRUCTOR__1 + :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> IO MapAccum +casadi__MapAccum__CONSTRUCTOR__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MapAccum__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mapAccum__1 :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> IO MapAccum +mapAccum__1 = casadi__MapAccum__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__2" c_casadi__MapAccum__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MapAccum') +casadi__MapAccum__CONSTRUCTOR__2 + :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> M.Map String GenericType -> IO MapAccum +casadi__MapAccum__CONSTRUCTOR__2 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MapAccum__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mapAccum__2 :: String -> Function -> Int -> Vector Bool -> Vector Int -> Bool -> M.Map String GenericType -> IO MapAccum +mapAccum__2 = casadi__MapAccum__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__MapAccum__CONSTRUCTOR__3" c_casadi__MapAccum__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> IO (Ptr MapAccum') +casadi__MapAccum__CONSTRUCTOR__3 + :: IO MapAccum +casadi__MapAccum__CONSTRUCTOR__3 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__MapAccum__CONSTRUCTOR__3 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +mapAccum__3 :: IO MapAccum +mapAccum__3 = casadi__MapAccum__CONSTRUCTOR__3 + diff --git a/Casadi/Core/Classes/MatrixCommon.hs b/Casadi/Core/Classes/MatrixCommon.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/MatrixCommon.hs @@ -0,0 +1,31 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.MatrixCommon + ( + MatrixCommon, + MatrixCommonClass(..), + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums diff --git a/Casadi/Core/Classes/NlpBuilder.hs b/Casadi/Core/Classes/NlpBuilder.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/NlpBuilder.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.Core.Classes.NlpBuilder + ( + NlpBuilder, + NlpBuilderClass(..), + nlpBuilder_getDescription, + nlpBuilder_getRepresentation, + nlpBuilder_parseNL__0, + nlpBuilder_parseNL__1, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__NlpBuilder__parseNL__0" c_casadi__NlpBuilder__parseNL__0 + :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> Ptr StdString -> IO () +casadi__NlpBuilder__parseNL__0 + :: NlpBuilder -> String -> IO () +casadi__NlpBuilder__parseNL__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpBuilder__parseNL__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpBuilder_parseNL__0 :: NlpBuilderClass a => a -> String -> IO () +nlpBuilder_parseNL__0 x = casadi__NlpBuilder__parseNL__0 (castNlpBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpBuilder__parseNL__1" c_casadi__NlpBuilder__parseNL__1 + :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO () +casadi__NlpBuilder__parseNL__1 + :: NlpBuilder -> String -> M.Map String GenericType -> IO () +casadi__NlpBuilder__parseNL__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpBuilder__parseNL__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpBuilder_parseNL__1 :: NlpBuilderClass a => a -> String -> M.Map String GenericType -> IO () +nlpBuilder_parseNL__1 x = casadi__NlpBuilder__parseNL__1 (castNlpBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpBuilder__getRepresentation" c_casadi__NlpBuilder__getRepresentation + :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> IO (Ptr StdString) +casadi__NlpBuilder__getRepresentation + :: NlpBuilder -> IO String +casadi__NlpBuilder__getRepresentation x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpBuilder__getRepresentation errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpBuilder_getRepresentation :: NlpBuilderClass a => a -> IO String +nlpBuilder_getRepresentation x = casadi__NlpBuilder__getRepresentation (castNlpBuilder x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpBuilder__getDescription" c_casadi__NlpBuilder__getDescription + :: Ptr (Ptr StdString) -> Ptr NlpBuilder' -> IO (Ptr StdString) +casadi__NlpBuilder__getDescription + :: NlpBuilder -> IO String +casadi__NlpBuilder__getDescription x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpBuilder__getDescription errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpBuilder_getDescription :: NlpBuilderClass a => a -> IO String +nlpBuilder_getDescription x = casadi__NlpBuilder__getDescription (castNlpBuilder x) + diff --git a/Casadi/Core/Classes/NlpSolver.hs b/Casadi/Core/Classes/NlpSolver.hs --- a/Casadi/Core/Classes/NlpSolver.hs +++ b/Casadi/Core/Classes/NlpSolver.hs @@ -11,6 +11,11 @@ NlpSolverClass(..), nlpSolver__0, nlpSolver__1, + nlpSolver__2, + nlpSolver__3, + nlpSolver__4, + nlpSolver__5, + nlpSolver__6, nlpSolver_doc, nlpSolver_getReducedHessian, nlpSolver_getReportConstraints, @@ -18,18 +23,17 @@ nlpSolver_hasPlugin, nlpSolver_hessLag, nlpSolver_jacG, - nlpSolver_joinFG, nlpSolver_loadPlugin, nlpSolver_nlp, nlpSolver_reportConstraints, nlpSolver_setOptionsFromFile, - nlpSolver_setQPOptions, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -37,52 +41,165 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__0" c_casadi__NlpSolver__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> IO (Ptr NlpSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> IO (Ptr NlpSolver') casadi__NlpSolver__CONSTRUCTOR__0 - :: String -> Function -> IO NlpSolver -casadi__NlpSolver__CONSTRUCTOR__0 x0 x1 = + :: String -> String -> M.Map String MX -> IO NlpSolver +casadi__NlpSolver__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__NlpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__NlpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -nlpSolver__0 :: String -> Function -> IO NlpSolver +nlpSolver__0 :: String -> String -> M.Map String MX -> IO NlpSolver nlpSolver__0 = casadi__NlpSolver__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__1" c_casadi__NlpSolver__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> IO (Ptr NlpSolver') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr NlpSolver') casadi__NlpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO NlpSolver +casadi__NlpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpSolver__1 :: String -> String -> M.Map String MX -> M.Map String GenericType -> IO NlpSolver +nlpSolver__1 = casadi__NlpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__2" c_casadi__NlpSolver__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> IO (Ptr NlpSolver') +casadi__NlpSolver__CONSTRUCTOR__2 + :: String -> String -> M.Map String SX -> IO NlpSolver +casadi__NlpSolver__CONSTRUCTOR__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpSolver__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpSolver__2 :: String -> String -> M.Map String SX -> IO NlpSolver +nlpSolver__2 = casadi__NlpSolver__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__3" c_casadi__NlpSolver__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr NlpSolver') +casadi__NlpSolver__CONSTRUCTOR__3 + :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO NlpSolver +casadi__NlpSolver__CONSTRUCTOR__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpSolver__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpSolver__3 :: String -> String -> M.Map String SX -> M.Map String GenericType -> IO NlpSolver +nlpSolver__3 = casadi__NlpSolver__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__4" c_casadi__NlpSolver__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> IO (Ptr NlpSolver') +casadi__NlpSolver__CONSTRUCTOR__4 + :: String -> String -> Function -> IO NlpSolver +casadi__NlpSolver__CONSTRUCTOR__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpSolver__CONSTRUCTOR__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpSolver__4 :: String -> String -> Function -> IO NlpSolver +nlpSolver__4 = casadi__NlpSolver__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__5" c_casadi__NlpSolver__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr NlpSolver') +casadi__NlpSolver__CONSTRUCTOR__5 + :: String -> String -> Function -> M.Map String GenericType -> IO NlpSolver +casadi__NlpSolver__CONSTRUCTOR__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__NlpSolver__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +nlpSolver__5 :: String -> String -> Function -> M.Map String GenericType -> IO NlpSolver +nlpSolver__5 = casadi__NlpSolver__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__NlpSolver__CONSTRUCTOR__6" c_casadi__NlpSolver__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> IO (Ptr NlpSolver') +casadi__NlpSolver__CONSTRUCTOR__6 :: IO NlpSolver -casadi__NlpSolver__CONSTRUCTOR__1 = +casadi__NlpSolver__CONSTRUCTOR__6 = do errStrPtrP <- new nullPtr - ret <- c_casadi__NlpSolver__CONSTRUCTOR__1 errStrPtrP + ret <- c_casadi__NlpSolver__CONSTRUCTOR__6 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -nlpSolver__1 :: IO NlpSolver -nlpSolver__1 = casadi__NlpSolver__CONSTRUCTOR__1 +nlpSolver__6 :: IO NlpSolver +nlpSolver__6 = casadi__NlpSolver__CONSTRUCTOR__6 -- direct wrapper @@ -226,27 +343,6 @@ -- direct wrapper -foreign import ccall unsafe "casadi__NlpSolver__joinFG" c_casadi__NlpSolver__joinFG - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr Function' -> IO (Ptr Function') -casadi__NlpSolver__joinFG - :: Function -> Function -> IO Function -casadi__NlpSolver__joinFG x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__NlpSolver__joinFG errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -nlpSolver_joinFG :: Function -> Function -> IO Function -nlpSolver_joinFG = casadi__NlpSolver__joinFG - - --- direct wrapper foreign import ccall unsafe "casadi__NlpSolver__loadPlugin" c_casadi__NlpSolver__loadPlugin :: Ptr (Ptr StdString) -> Ptr StdString -> IO () casadi__NlpSolver__loadPlugin @@ -325,24 +421,4 @@ -- classy wrapper nlpSolver_setOptionsFromFile :: NlpSolverClass a => a -> String -> IO () nlpSolver_setOptionsFromFile x = casadi__NlpSolver__setOptionsFromFile (castNlpSolver x) - - --- direct wrapper -foreign import ccall unsafe "casadi__NlpSolver__setQPOptions" c_casadi__NlpSolver__setQPOptions - :: Ptr (Ptr StdString) -> Ptr NlpSolver' -> IO () -casadi__NlpSolver__setQPOptions - :: NlpSolver -> IO () -casadi__NlpSolver__setQPOptions x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__NlpSolver__setQPOptions errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -nlpSolver_setQPOptions :: NlpSolverClass a => a -> IO () -nlpSolver_setQPOptions x = casadi__NlpSolver__setQPOptions (castNlpSolver x) diff --git a/Casadi/Core/Classes/Nullspace.hs b/Casadi/Core/Classes/Nullspace.hs --- a/Casadi/Core/Classes/Nullspace.hs +++ b/Casadi/Core/Classes/Nullspace.hs @@ -16,6 +16,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -23,9 +24,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data diff --git a/Casadi/Core/Classes/OptionsFunctionality.hs b/Casadi/Core/Classes/OptionsFunctionality.hs --- a/Casadi/Core/Classes/OptionsFunctionality.hs +++ b/Casadi/Core/Classes/OptionsFunctionality.hs @@ -10,8 +10,10 @@ OptionsFunctionality, OptionsFunctionalityClass(..), optionsFunctionality, + optionsFunctionality_addOptionRecipe, optionsFunctionality_copyOptions__0, optionsFunctionality_copyOptions__1, + optionsFunctionality_dictionary, optionsFunctionality_getOption, optionsFunctionality_getOptionAllowed, optionsFunctionality_getOptionAllowedIndex, @@ -24,15 +26,18 @@ optionsFunctionality_hasOption, optionsFunctionality_hasSetOption, optionsFunctionality_printOptions, - optionsFunctionality_setOption, optionsFunctionality_setOptionByAllowedIndex, optionsFunctionality_setOptionByEnumValue, + optionsFunctionality_setOption__0, + optionsFunctionality_setOption__1, + optionsFunctionality_setOption__2, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -40,9 +45,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data @@ -68,6 +72,27 @@ -- direct wrapper +foreign import ccall unsafe "casadi__OptionsFunctionality__addOptionRecipe" c_casadi__OptionsFunctionality__addOptionRecipe + :: Ptr (Ptr StdString) -> Ptr (StdMap StdString (Ptr GenericType')) -> Ptr StdString -> IO (Ptr (StdMap StdString (Ptr GenericType'))) +casadi__OptionsFunctionality__addOptionRecipe + :: M.Map String GenericType -> String -> IO (M.Map String GenericType) +casadi__OptionsFunctionality__addOptionRecipe x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__OptionsFunctionality__addOptionRecipe errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +optionsFunctionality_addOptionRecipe :: M.Map String GenericType -> String -> IO (M.Map String GenericType) +optionsFunctionality_addOptionRecipe = casadi__OptionsFunctionality__addOptionRecipe + + +-- direct wrapper foreign import ccall unsafe "casadi__OptionsFunctionality__copyOptions__0" c_casadi__OptionsFunctionality__copyOptions__0 :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr OptionsFunctionality' -> IO () casadi__OptionsFunctionality__copyOptions__0 @@ -111,6 +136,26 @@ -- direct wrapper +foreign import ccall unsafe "casadi__OptionsFunctionality__dictionary" c_casadi__OptionsFunctionality__dictionary + :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> IO (Ptr (StdMap StdString (Ptr GenericType'))) +casadi__OptionsFunctionality__dictionary + :: OptionsFunctionality -> IO (M.Map String GenericType) +casadi__OptionsFunctionality__dictionary x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__OptionsFunctionality__dictionary errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +optionsFunctionality_dictionary :: OptionsFunctionalityClass a => a -> IO (M.Map String GenericType) +optionsFunctionality_dictionary x = casadi__OptionsFunctionality__dictionary (castOptionsFunctionality x) + + +-- direct wrapper foreign import ccall unsafe "casadi__OptionsFunctionality__getOption" c_casadi__OptionsFunctionality__getOption :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO (Ptr GenericType') casadi__OptionsFunctionality__getOption @@ -260,7 +305,7 @@ foreign import ccall unsafe "casadi__OptionsFunctionality__getOptionType" c_casadi__OptionsFunctionality__getOptionType :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> IO CInt casadi__OptionsFunctionality__getOptionType - :: OptionsFunctionality -> String -> IO Opt_type + :: OptionsFunctionality -> String -> IO TypeID casadi__OptionsFunctionality__getOptionType x0 x1 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> @@ -273,7 +318,7 @@ -- classy wrapper -optionsFunctionality_getOptionType :: OptionsFunctionalityClass a => a -> String -> IO Opt_type +optionsFunctionality_getOptionType :: OptionsFunctionalityClass a => a -> String -> IO TypeID optionsFunctionality_getOptionType x = casadi__OptionsFunctionality__getOptionType (castOptionsFunctionality x) @@ -361,25 +406,68 @@ -- direct wrapper -foreign import ccall unsafe "casadi__OptionsFunctionality__setOption" c_casadi__OptionsFunctionality__setOption +foreign import ccall unsafe "casadi__OptionsFunctionality__setOption__0" c_casadi__OptionsFunctionality__setOption__0 + :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO () +casadi__OptionsFunctionality__setOption__0 + :: OptionsFunctionality -> M.Map String GenericType -> IO () +casadi__OptionsFunctionality__setOption__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__OptionsFunctionality__setOption__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +optionsFunctionality_setOption__0 :: OptionsFunctionalityClass a => a -> M.Map String GenericType -> IO () +optionsFunctionality_setOption__0 x = casadi__OptionsFunctionality__setOption__0 (castOptionsFunctionality x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__OptionsFunctionality__setOption__1" c_casadi__OptionsFunctionality__setOption__1 + :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr (StdMap StdString (Ptr GenericType')) -> CInt -> IO () +casadi__OptionsFunctionality__setOption__1 + :: OptionsFunctionality -> M.Map String GenericType -> Bool -> IO () +casadi__OptionsFunctionality__setOption__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__OptionsFunctionality__setOption__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +optionsFunctionality_setOption__1 :: OptionsFunctionalityClass a => a -> M.Map String GenericType -> Bool -> IO () +optionsFunctionality_setOption__1 x = casadi__OptionsFunctionality__setOption__1 (castOptionsFunctionality x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__OptionsFunctionality__setOption__2" c_casadi__OptionsFunctionality__setOption__2 :: Ptr (Ptr StdString) -> Ptr OptionsFunctionality' -> Ptr StdString -> Ptr GenericType' -> IO () -casadi__OptionsFunctionality__setOption +casadi__OptionsFunctionality__setOption__2 :: OptionsFunctionality -> String -> GenericType -> IO () -casadi__OptionsFunctionality__setOption x0 x1 x2 = +casadi__OptionsFunctionality__setOption__2 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__OptionsFunctionality__setOption errStrPtrP x0' x1' x2' + ret <- c_casadi__OptionsFunctionality__setOption__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -optionsFunctionality_setOption :: OptionsFunctionalityClass a => a -> String -> GenericType -> IO () -optionsFunctionality_setOption x = casadi__OptionsFunctionality__setOption (castOptionsFunctionality x) +optionsFunctionality_setOption__2 :: OptionsFunctionalityClass a => a -> String -> GenericType -> IO () +optionsFunctionality_setOption__2 x = casadi__OptionsFunctionality__setOption__2 (castOptionsFunctionality x) -- direct wrapper diff --git a/Casadi/Core/Classes/Parallelizer.hs b/Casadi/Core/Classes/Parallelizer.hs deleted file mode 100644 --- a/Casadi/Core/Classes/Parallelizer.hs +++ /dev/null @@ -1,72 +0,0 @@ -{-# OPTIONS_GHC -Wall #-} -{-# OPTIONS_GHC -fno-warn-unused-imports #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# Language ForeignFunctionInterface #-} -{-# Language FlexibleInstances #-} -{-# Language MultiParamTypeClasses #-} - -module Casadi.Core.Classes.Parallelizer - ( - Parallelizer, - ParallelizerClass(..), - parallelizer__0, - parallelizer__1, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__Parallelizer__CONSTRUCTOR__0" c_casadi__Parallelizer__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Function')) -> IO (Ptr Parallelizer') -casadi__Parallelizer__CONSTRUCTOR__0 - :: Vector Function -> IO Parallelizer -casadi__Parallelizer__CONSTRUCTOR__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Parallelizer__CONSTRUCTOR__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -parallelizer__0 :: Vector Function -> IO Parallelizer -parallelizer__0 = casadi__Parallelizer__CONSTRUCTOR__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__Parallelizer__CONSTRUCTOR__1" c_casadi__Parallelizer__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> IO (Ptr Parallelizer') -casadi__Parallelizer__CONSTRUCTOR__1 - :: IO Parallelizer -casadi__Parallelizer__CONSTRUCTOR__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Parallelizer__CONSTRUCTOR__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -parallelizer__1 :: IO Parallelizer -parallelizer__1 = casadi__Parallelizer__CONSTRUCTOR__1 - diff --git a/Casadi/Core/Classes/QcqpSolver.hs b/Casadi/Core/Classes/QcqpSolver.hs --- a/Casadi/Core/Classes/QcqpSolver.hs +++ b/Casadi/Core/Classes/QcqpSolver.hs @@ -9,17 +9,19 @@ ( QcqpSolver, QcqpSolverClass(..), - qcqpSolver, + qcqpSolver__0, + qcqpSolver__1, + qcqpSolver__2, qcqpSolver_doc, qcqpSolver_hasPlugin, qcqpSolver_loadPlugin, - qcqpSolver_setQPOptions, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -27,31 +29,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR" c_casadi__QcqpSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR__0" c_casadi__QcqpSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr QcqpSolver') +casadi__QcqpSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO QcqpSolver +casadi__QcqpSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__QcqpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +qcqpSolver__0 :: String -> String -> M.Map String Sparsity -> IO QcqpSolver +qcqpSolver__0 = casadi__QcqpSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR__1" c_casadi__QcqpSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr QcqpSolver') +casadi__QcqpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QcqpSolver +casadi__QcqpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__QcqpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +qcqpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QcqpSolver +qcqpSolver__1 = casadi__QcqpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR__2" c_casadi__QcqpSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr QcqpSolver') -casadi__QcqpSolver__CONSTRUCTOR +casadi__QcqpSolver__CONSTRUCTOR__2 :: IO QcqpSolver -casadi__QcqpSolver__CONSTRUCTOR = +casadi__QcqpSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__QcqpSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__QcqpSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -qcqpSolver :: IO QcqpSolver -qcqpSolver = casadi__QcqpSolver__CONSTRUCTOR +qcqpSolver__2 :: IO QcqpSolver +qcqpSolver__2 = casadi__QcqpSolver__CONSTRUCTOR__2 -- direct wrapper @@ -112,24 +158,4 @@ -- classy wrapper qcqpSolver_loadPlugin :: String -> IO () qcqpSolver_loadPlugin = casadi__QcqpSolver__loadPlugin - - --- direct wrapper -foreign import ccall unsafe "casadi__QcqpSolver__setQPOptions" c_casadi__QcqpSolver__setQPOptions - :: Ptr (Ptr StdString) -> Ptr QcqpSolver' -> IO () -casadi__QcqpSolver__setQPOptions - :: QcqpSolver -> IO () -casadi__QcqpSolver__setQPOptions x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__QcqpSolver__setQPOptions errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -qcqpSolver_setQPOptions :: QcqpSolverClass a => a -> IO () -qcqpSolver_setQPOptions x = casadi__QcqpSolver__setQPOptions (castQcqpSolver x) diff --git a/Casadi/Core/Classes/QpSolver.hs b/Casadi/Core/Classes/QpSolver.hs --- a/Casadi/Core/Classes/QpSolver.hs +++ b/Casadi/Core/Classes/QpSolver.hs @@ -9,18 +9,20 @@ ( QpSolver, QpSolverClass(..), - qpSolver, + qpSolver__0, + qpSolver__1, + qpSolver__2, qpSolver_doc, qpSolver_generateNativeCode, qpSolver_hasPlugin, qpSolver_loadPlugin, - qpSolver_setLPOptions, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -28,31 +30,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR" c_casadi__QpSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR__0" c_casadi__QpSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr QpSolver') +casadi__QpSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO QpSolver +casadi__QpSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__QpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +qpSolver__0 :: String -> String -> M.Map String Sparsity -> IO QpSolver +qpSolver__0 = casadi__QpSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR__1" c_casadi__QpSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr QpSolver') +casadi__QpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QpSolver +casadi__QpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__QpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +qpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO QpSolver +qpSolver__1 = casadi__QpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR__2" c_casadi__QpSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr QpSolver') -casadi__QpSolver__CONSTRUCTOR +casadi__QpSolver__CONSTRUCTOR__2 :: IO QpSolver -casadi__QpSolver__CONSTRUCTOR = +casadi__QpSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__QpSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__QpSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -qpSolver :: IO QpSolver -qpSolver = casadi__QpSolver__CONSTRUCTOR +qpSolver__2 :: IO QpSolver +qpSolver__2 = casadi__QpSolver__CONSTRUCTOR__2 -- direct wrapper @@ -134,24 +180,4 @@ -- classy wrapper qpSolver_loadPlugin :: String -> IO () qpSolver_loadPlugin = casadi__QpSolver__loadPlugin - - --- direct wrapper -foreign import ccall unsafe "casadi__QpSolver__setLPOptions" c_casadi__QpSolver__setLPOptions - :: Ptr (Ptr StdString) -> Ptr QpSolver' -> IO () -casadi__QpSolver__setLPOptions - :: QpSolver -> IO () -casadi__QpSolver__setLPOptions x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__QpSolver__setLPOptions errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -qpSolver_setLPOptions :: QpSolverClass a => a -> IO () -qpSolver_setLPOptions x = casadi__QpSolver__setLPOptions (castQpSolver x) diff --git a/Casadi/Core/Classes/SX.hs b/Casadi/Core/Classes/SX.hs --- a/Casadi/Core/Classes/SX.hs +++ b/Casadi/Core/Classes/SX.hs @@ -21,7262 +21,3957 @@ sx__7, sx__8, sx__9, - sx___constpow__, - sx___copysign__, - sx___mldivide__, - sx___mrdivide__, - sx___nonzero__, - sx___truediv____0, - sx___truediv____1, - sx_append, - sx_appendColumns, - sx_binary, - sx_className, - sx_clear, - sx_colind, - sx_dimString, - sx_enlarge__0, - sx_enlarge__1, - sx_erase__0, - sx_erase__1, - sx_erase__2, - sx_erase__3, - sx_eye, - sx_find__0, - sx_find__1, - sx_getColind, - sx_getDep__0, - sx_getDep__1, - sx_getDescription, - sx_getElementHash, - sx_getEqualityCheckingDepth, - sx_getIntValue, - sx_getMaxNumCallsInPrint, - sx_getNZ__0, - sx_getNZ__1, - sx_getNZ__2, - sx_getName, - sx_getNdeps, - sx_getRepresentation, - sx_getRow, - sx_getSparsity, - sx_getSym, - sx_getValue__0, - sx_getValue__1, - sx_get__0, - sx_get__1, - sx_get__2, - sx_get__3, - sx_get__4, - sx_get__5, - sx_get__6, - sx_get__7, - sx_hasNZ, - sx_hasNonStructuralZeros, - sx_inf__0, - sx_inf__1, - sx_inf__2, - sx_inf__3, - sx_isCommutative, - sx_isConstant, - sx_isDense, - sx_isEmpty__0, - sx_isEmpty__1, - sx_isIdentity, - sx_isInteger, - sx_isLeaf, - sx_isMinusOne, - sx_isOne, - sx_isRegular, - sx_isRowVector, - sx_isScalar__0, - sx_isScalar__1, - sx_isSlice__0, - sx_isSlice__1, - sx_isSmooth, - sx_isSquare, - sx_isSymbolic, - sx_isSymbolicSparse, - sx_isTril, - sx_isTriu, - sx_isVector__0, - sx_isVector__1, - sx_isZero, - sx_makeSparse__0, - sx_makeSparse__1, - sx_matrix_matrix, - sx_matrix_scalar, - sx_nan__0, - sx_nan__1, - sx_nan__2, - sx_nan__3, - sx_nnz, - sx_nonzeros, - sx_nonzeros_int, - sx_numel__0, - sx_numel__1, - sx_ones__0, - sx_ones__1, - sx_ones__2, - sx_ones__3, - sx_operator_minus, - sx_operator_plus, - sx_printDense, - sx_printScalar, - sx_printSparse, - sx_printVector, - sx_printme, - sx_remove, - sx_reserve__0, - sx_reserve__1, - sx_resize, - sx_row, - sx_sanityCheck__0, - sx_sanityCheck__1, - sx_scalar_matrix, - sx_setEqualityCheckingDepth__0, - sx_setEqualityCheckingDepth__1, - sx_setMaxNumCallsInPrint__0, - sx_setMaxNumCallsInPrint__1, - sx_setNZ__0, - sx_setNZ__1, - sx_setNZ__2, - sx_setNZ__3, - sx_setPrecision, - sx_setScientific, - sx_setSparse__0, - sx_setSparse__1, - sx_setSym, - sx_setValue__0, - sx_setValue__1, - sx_setWidth, - sx_setZero, - sx_set__0, - sx_set__1, - sx_set__10, - sx_set__2, - sx_set__3, - sx_set__4, - sx_set__5, - sx_set__6, - sx_set__7, - sx_set__8, - sx_set__9, - sx_size1, - sx_size2, - sx_sizeD, - sx_sizeL, - sx_sizeU, - sx_size__0, - sx_size__1, - sx_sparse__0, - sx_sparse__1, - sx_sparse__2, - sx_sparse__3, - sx_sparsity, - sx_sparsityRef, - sx_sym__0, - sx_sym__1, - sx_sym__2, - sx_sym__3, - sx_sym__4, - sx_sym__5, - sx_sym__6, - sx_sym__7, - sx_toSlice__0, - sx_toSlice__1, - sx_triplet__0, - sx_triplet__1, - sx_unary, - sx_zeros__0, - sx_zeros__1, - sx_zeros__2, - sx_zeros__3, - sx_zz_abs, - sx_zz_acos, - sx_zz_acosh, - sx_zz_adj, - sx_zz_all, - sx_zz_and, - sx_zz_any, - sx_zz_asin, - sx_zz_asinh, - sx_zz_atan, - sx_zz_atan2, - sx_zz_atanh, - sx_zz_blockcat, - sx_zz_blocksplit, - sx_zz_ceil, - sx_zz_cofactor, - sx_zz_cos, - sx_zz_cosh, - sx_zz_countNodes, - sx_zz_cross__0, - sx_zz_cross__1, - sx_zz_densify, - sx_zz_dependsOn, - sx_zz_det, - sx_zz_diag, - sx_zz_diagcat, - sx_zz_diagsplit, - sx_zz_eig_symbolic, - sx_zz_eq, - sx_zz_erf, - sx_zz_erfinv, - sx_zz_exp, - sx_zz_expand, - sx_zz_extractShared__0, - sx_zz_extractShared__1, - sx_zz_extractShared__2, - sx_zz_floor, - sx_zz_gauss_quadrature__0, - sx_zz_gauss_quadrature__1, - sx_zz_gauss_quadrature__2, - sx_zz_ge, - sx_zz_getMinor, - sx_zz_getOperatorRepresentation, - sx_zz_getSymbols__0, - sx_zz_getSymbols__1, - sx_zz_gradient, - sx_zz_gt, - sx_zz_heaviside, - sx_zz_hessian__0, - sx_zz_hessian__1, - sx_zz_horzcat, - sx_zz_horzsplit, - sx_zz_if_else, - sx_zz_if_else_zero, - sx_zz_inner_prod, - sx_zz_inv, - sx_zz_isEqual__0, - sx_zz_isEqual__1, - sx_zz_jacobian, - sx_zz_jacobianTimesVector__0, - sx_zz_jacobianTimesVector__1, - sx_zz_kron, - sx_zz_le, - sx_zz_linspace, - sx_zz_log, - sx_zz_log10, - sx_zz_lt, - sx_zz_max, - sx_zz_min, - sx_zz_minus, - sx_zz_mod, - sx_zz_mpower, - sx_zz_mtaylor__0, - sx_zz_mtaylor__1, - sx_zz_mtaylor__2, - sx_zz_mtimes__0, - sx_zz_mtimes__1, - sx_zz_ne, - sx_zz_norm_0_mul, - sx_zz_norm_1, - sx_zz_norm_2, - sx_zz_norm_F, - sx_zz_norm_inf, - sx_zz_norm_inf_mul, - sx_zz_not, - sx_zz_nullspace, - sx_zz_or, - sx_zz_outer_prod, - sx_zz_pinv, - sx_zz_plus, - sx_zz_poly_coeff, - sx_zz_poly_roots, - sx_zz_polyval, - sx_zz_power, - sx_zz_printCompact, - sx_zz_project, - sx_zz_pw_const, - sx_zz_pw_lin, - sx_zz_qr, - sx_zz_quad_form__0, - sx_zz_quad_form__1, - sx_zz_quad_form__2, - sx_zz_quad_form__3, - sx_zz_ramp, - sx_zz_rdivide, - sx_zz_rectangle, - sx_zz_repmat__0, - sx_zz_repmat__1, - sx_zz_reshape__0, - sx_zz_reshape__1, - sx_zz_sign, - sx_zz_simplify, - sx_zz_sin, - sx_zz_sinh, - sx_zz_solve, - sx_zz_sparsify__0, - sx_zz_sparsify__1, - sx_zz_sprank, - sx_zz_spy, - sx_zz_sqrt, - sx_zz_substituteInPlace__0, - sx_zz_substituteInPlace__1, - sx_zz_substitute__0, - sx_zz_substitute__1, - sx_zz_sumAll, - sx_zz_sumCols, - sx_zz_sumRows, - sx_zz_sum_square, - sx_zz_tan, - sx_zz_tangent, - sx_zz_tanh, - sx_zz_taylor__0, - sx_zz_taylor__1, - sx_zz_taylor__2, - sx_zz_times, - sx_zz_trace, - sx_zz_triangle, - sx_zz_tril2symm, - sx_zz_tril__0, - sx_zz_tril__1, - sx_zz_triu2symm, - sx_zz_triu__0, - sx_zz_triu__1, - sx_zz_unite, - sx_zz_vec, - sx_zz_vecNZ, - sx_zz_vecNZcat, - sx_zz_veccat, - sx_zz_vertcat, - sx_zz_vertsplit, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__0" c_casadi__SX__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__0 - :: Vector Double -> IO SX -casadi__SX__CONSTRUCTOR__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__0 :: Vector Double -> IO SX -sx__0 = casadi__SX__CONSTRUCTOR__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__1" c_casadi__SX__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__1 - :: DMatrix -> IO SX -casadi__SX__CONSTRUCTOR__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__1 :: DMatrix -> IO SX -sx__1 = casadi__SX__CONSTRUCTOR__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__2" c_casadi__SX__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__2 - :: Vector Int -> IO SX -casadi__SX__CONSTRUCTOR__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__2 :: Vector Int -> IO SX -sx__2 = casadi__SX__CONSTRUCTOR__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__3" c_casadi__SX__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__3 - :: IMatrix -> IO SX -casadi__SX__CONSTRUCTOR__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__3 :: IMatrix -> IO SX -sx__3 = casadi__SX__CONSTRUCTOR__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__4" c_casadi__SX__CONSTRUCTOR__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__4 - :: Vector (Vector Double) -> IO SX -casadi__SX__CONSTRUCTOR__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__4 :: Vector (Vector Double) -> IO SX -sx__4 = casadi__SX__CONSTRUCTOR__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__5" c_casadi__SX__CONSTRUCTOR__5 - :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__5 - :: Double -> IO SX -casadi__SX__CONSTRUCTOR__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__5 :: Double -> IO SX -sx__5 = casadi__SX__CONSTRUCTOR__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__6" c_casadi__SX__CONSTRUCTOR__6 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__6 - :: Sparsity -> SX -> IO SX -casadi__SX__CONSTRUCTOR__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__6 :: Sparsity -> SX -> IO SX -sx__6 = casadi__SX__CONSTRUCTOR__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__7" c_casadi__SX__CONSTRUCTOR__7 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__7 - :: Sparsity -> IO SX -casadi__SX__CONSTRUCTOR__7 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__7 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__7 :: Sparsity -> IO SX -sx__7 = casadi__SX__CONSTRUCTOR__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__8" c_casadi__SX__CONSTRUCTOR__8 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__8 - :: Int -> Int -> IO SX -casadi__SX__CONSTRUCTOR__8 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__8 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__8 :: Int -> Int -> IO SX -sx__8 = casadi__SX__CONSTRUCTOR__8 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__9" c_casadi__SX__CONSTRUCTOR__9 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__9 - :: SX -> IO SX -casadi__SX__CONSTRUCTOR__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__9 :: SX -> IO SX -sx__9 = casadi__SX__CONSTRUCTOR__9 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__10" c_casadi__SX__CONSTRUCTOR__10 - :: Ptr (Ptr StdString) -> IO (Ptr SX') -casadi__SX__CONSTRUCTOR__10 - :: IO SX -casadi__SX__CONSTRUCTOR__10 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__CONSTRUCTOR__10 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx__10 :: IO SX -sx__10 = casadi__SX__CONSTRUCTOR__10 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__T" c_casadi__SX__T - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__T - :: SX -> IO SX -casadi__SX__T x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__T errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_T :: SXClass a => a -> IO SX -sx_T x = casadi__SX__T (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX____constpow__" c_casadi__SX____constpow__ - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX____constpow__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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____copysign__" c_casadi__SX____copysign__ - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX____copysign__ - :: SX -> SX -> IO SX -casadi__SX____copysign__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX____copysign__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx___copysign__ :: SXClass a => a -> SX -> IO SX -sx___copysign__ x = casadi__SX____copysign__ (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX____mldivide__" c_casadi__SX____mldivide__ - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX____mldivide__ - :: SX -> SX -> IO SX -casadi__SX____mldivide__ x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX____mldivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx___mldivide__ :: SXClass a => a -> SX -> IO SX -sx___mldivide__ x = casadi__SX____mldivide__ (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX____mrdivide__" c_casadi__SX____mrdivide__ - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX____mrdivide__ errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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____nonzero__" c_casadi__SX____nonzero__ - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX____nonzero__ - :: SX -> IO Bool -casadi__SX____nonzero__ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX____nonzero__ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx___nonzero__ :: SXClass a => a -> IO Bool -sx___nonzero__ x = casadi__SX____nonzero__ (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX____truediv____0" c_casadi__SX____truediv____0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX____truediv____0 - :: SX -> SX -> IO SX -casadi__SX____truediv____0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX____truediv____0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx___truediv____0 :: SXClass a => a -> SX -> IO SX -sx___truediv____0 x = casadi__SX____truediv____0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX____truediv____1" c_casadi__SX____truediv____1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX____truediv____1 - :: SX -> SX -> IO SX -casadi__SX____truediv____1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX____truediv____1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx___truediv____1 :: SXClass a => a -> SX -> IO SX -sx___truediv____1 x = casadi__SX____truediv____1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__append" c_casadi__SX__append - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO () -casadi__SX__append - :: SX -> SX -> IO () -casadi__SX__append x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__append errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_append :: SXClass a => a -> SX -> IO () -sx_append x = casadi__SX__append (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__appendColumns" c_casadi__SX__appendColumns - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO () -casadi__SX__appendColumns - :: SX -> SX -> IO () -casadi__SX__appendColumns x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__appendColumns errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_appendColumns :: SXClass a => a -> SX -> IO () -sx_appendColumns x = casadi__SX__appendColumns (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__binary" c_casadi__SX__binary - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__binary errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_binary :: Int -> SX -> SX -> IO SX -sx_binary = casadi__SX__binary - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__className" c_casadi__SX__className - :: Ptr (Ptr StdString) -> IO (Ptr StdString) -casadi__SX__className - :: IO String -casadi__SX__className = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__className errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_className :: IO String -sx_className = casadi__SX__className - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__clear" c_casadi__SX__clear - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__clear - :: SX -> IO () -casadi__SX__clear x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__clear errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_clear :: SXClass a => a -> IO () -sx_clear x = casadi__SX__clear (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__colind" c_casadi__SX__colind - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__colind - :: SX -> Int -> IO Int -casadi__SX__colind x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__colind errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_colind :: SXClass a => a -> Int -> IO Int -sx_colind x = casadi__SX__colind (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__dimString" c_casadi__SX__dimString - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString) -casadi__SX__dimString - :: SX -> IO String -casadi__SX__dimString x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__dimString errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_dimString :: SXClass a => a -> IO String -sx_dimString x = casadi__SX__dimString (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__enlarge__0" c_casadi__SX__enlarge__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__SX__enlarge__0 - :: SX -> Int -> Int -> Vector Int -> Vector Int -> IO () -casadi__SX__enlarge__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_enlarge__0 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () -sx_enlarge__0 x = casadi__SX__enlarge__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__enlarge__1" c_casadi__SX__enlarge__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__SX__enlarge__1 - :: SX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -casadi__SX__enlarge__1 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_enlarge__1 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -sx_enlarge__1 x = casadi__SX__enlarge__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__erase__0" c_casadi__SX__erase__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO () -casadi__SX__erase__0 - :: SX -> Vector Int -> IO () -casadi__SX__erase__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__erase__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_erase__0 :: SXClass a => a -> Vector Int -> IO () -sx_erase__0 x = casadi__SX__erase__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__erase__1" c_casadi__SX__erase__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__SX__erase__1 - :: SX -> Vector Int -> Bool -> IO () -casadi__SX__erase__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__erase__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_erase__1 :: SXClass a => a -> Vector Int -> Bool -> IO () -sx_erase__1 x = casadi__SX__erase__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__erase__2" c_casadi__SX__erase__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__SX__erase__2 - :: SX -> Vector Int -> Vector Int -> IO () -casadi__SX__erase__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__erase__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_erase__2 :: SXClass a => a -> Vector Int -> Vector Int -> IO () -sx_erase__2 x = casadi__SX__erase__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__erase__3" c_casadi__SX__erase__3 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__SX__erase__3 - :: SX -> Vector Int -> Vector Int -> Bool -> IO () -casadi__SX__erase__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__erase__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_erase__3 :: SXClass a => a -> Vector Int -> Vector Int -> Bool -> IO () -sx_erase__3 x = casadi__SX__erase__3 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__eye" c_casadi__SX__eye - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') -casadi__SX__eye - :: Int -> IO SX -casadi__SX__eye x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__eye errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_eye :: Int -> IO SX -sx_eye = casadi__SX__eye - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__find__0" c_casadi__SX__find__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) -casadi__SX__find__0 - :: SX -> IO (Vector Int) -casadi__SX__find__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__find__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_find__0 :: SXClass a => a -> IO (Vector Int) -sx_find__0 x = casadi__SX__find__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__find__1" c_casadi__SX__find__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec CInt)) -casadi__SX__find__1 - :: SX -> Bool -> IO (Vector Int) -casadi__SX__find__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__find__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_find__1 :: SXClass a => a -> Bool -> IO (Vector Int) -sx_find__1 x = casadi__SX__find__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__0" c_casadi__SX__get__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__SX__get__0 - :: SX -> SX -> Bool -> IMatrix -> IMatrix -> IO () -casadi__SX__get__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IMatrix -> IO () -sx_get__0 x = casadi__SX__get__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__1" c_casadi__SX__get__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__SX__get__1 - :: SX -> SX -> Bool -> IMatrix -> Slice -> IO () -casadi__SX__get__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__1 :: SXClass a => a -> SX -> Bool -> IMatrix -> Slice -> IO () -sx_get__1 x = casadi__SX__get__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__2" c_casadi__SX__get__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__SX__get__2 - :: SX -> SX -> Bool -> Slice -> IMatrix -> IO () -casadi__SX__get__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__2 :: SXClass a => a -> SX -> Bool -> Slice -> IMatrix -> IO () -sx_get__2 x = casadi__SX__get__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__3" c_casadi__SX__get__3 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__SX__get__3 - :: SX -> SX -> Bool -> Slice -> Slice -> IO () -casadi__SX__get__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__3 :: SXClass a => a -> SX -> Bool -> Slice -> Slice -> IO () -sx_get__3 x = casadi__SX__get__3 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__4" c_casadi__SX__get__4 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Sparsity' -> IO () -casadi__SX__get__4 - :: SX -> SX -> Bool -> Sparsity -> IO () -casadi__SX__get__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__4 :: SXClass a => a -> SX -> Bool -> Sparsity -> IO () -sx_get__4 x = casadi__SX__get__4 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__5" c_casadi__SX__get__5 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () -casadi__SX__get__5 - :: SX -> SX -> Bool -> IMatrix -> IO () -casadi__SX__get__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__5 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () -sx_get__5 x = casadi__SX__get__5 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__6" c_casadi__SX__get__6 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () -casadi__SX__get__6 - :: SX -> SX -> Bool -> Slice -> IO () -casadi__SX__get__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__6 :: SXClass a => a -> SX -> Bool -> Slice -> IO () -sx_get__6 x = casadi__SX__get__6 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__get__7" c_casadi__SX__get__7 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SX__get__7 - :: SX -> Vector Double -> IO () -casadi__SX__get__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__get__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_get__7 :: SXClass a => a -> Vector Double -> IO () -sx_get__7 x = casadi__SX__get__7 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getColind" c_casadi__SX__getColind - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) -casadi__SX__getColind - :: SX -> IO (Vector Int) -casadi__SX__getColind x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getColind errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getColind :: SXClass a => a -> IO (Vector Int) -sx_getColind x = casadi__SX__getColind (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getDep__0" c_casadi__SX__getDep__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__getDep__0 - :: SX -> IO SX -casadi__SX__getDep__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getDep__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getDep__0 :: SXClass a => a -> IO SX -sx_getDep__0 x = casadi__SX__getDep__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getDep__1" c_casadi__SX__getDep__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__getDep__1 - :: SX -> Int -> IO SX -casadi__SX__getDep__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getDep__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getDep__1 :: SXClass a => a -> Int -> IO SX -sx_getDep__1 x = casadi__SX__getDep__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getElementHash" c_casadi__SX__getElementHash - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CLong -casadi__SX__getElementHash - :: SX -> IO Int -casadi__SX__getElementHash x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getElementHash errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getElementHash :: SXClass a => a -> IO Int -sx_getElementHash x = casadi__SX__getElementHash (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getEqualityCheckingDepth" c_casadi__SX__getEqualityCheckingDepth - :: Ptr (Ptr StdString) -> IO CInt -casadi__SX__getEqualityCheckingDepth - :: IO Int -casadi__SX__getEqualityCheckingDepth = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getEqualityCheckingDepth errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getEqualityCheckingDepth :: IO Int -sx_getEqualityCheckingDepth = casadi__SX__getEqualityCheckingDepth - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getIntValue" c_casadi__SX__getIntValue - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__getIntValue - :: SX -> IO Int -casadi__SX__getIntValue x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getIntValue errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__getMaxNumCallsInPrint" c_casadi__SX__getMaxNumCallsInPrint - :: Ptr (Ptr StdString) -> IO CLong -casadi__SX__getMaxNumCallsInPrint - :: IO Int -casadi__SX__getMaxNumCallsInPrint = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getMaxNumCallsInPrint errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getMaxNumCallsInPrint :: IO Int -sx_getMaxNumCallsInPrint = casadi__SX__getMaxNumCallsInPrint - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getNZ__0" c_casadi__SX__getNZ__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () -casadi__SX__getNZ__0 - :: SX -> SX -> Bool -> IMatrix -> IO () -casadi__SX__getNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getNZ__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () -sx_getNZ__0 x = casadi__SX__getNZ__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getNZ__1" c_casadi__SX__getNZ__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () -casadi__SX__getNZ__1 - :: SX -> SX -> Bool -> Slice -> IO () -casadi__SX__getNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getNZ__1 :: SXClass a => a -> SX -> Bool -> Slice -> IO () -sx_getNZ__1 x = casadi__SX__getNZ__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getNZ__2" c_casadi__SX__getNZ__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SX__getNZ__2 - :: SX -> Vector Double -> IO () -casadi__SX__getNZ__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getNZ__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getNZ__2 :: SXClass a => a -> Vector Double -> IO () -sx_getNZ__2 x = casadi__SX__getNZ__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getName" c_casadi__SX__getName - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString) -casadi__SX__getName - :: SX -> IO String -casadi__SX__getName x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getName errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getName :: SXClass a => a -> IO String -sx_getName x = casadi__SX__getName (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getNdeps" c_casadi__SX__getNdeps - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__getNdeps - :: SX -> IO Int -casadi__SX__getNdeps x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getNdeps errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getNdeps :: SXClass a => a -> IO Int -sx_getNdeps x = casadi__SX__getNdeps (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getRow" c_casadi__SX__getRow - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) -casadi__SX__getRow - :: SX -> IO (Vector Int) -casadi__SX__getRow x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getRow errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getRow :: SXClass a => a -> IO (Vector Int) -sx_getRow x = casadi__SX__getRow (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getSparsity" c_casadi__SX__getSparsity - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity') -casadi__SX__getSparsity - :: SX -> IO Sparsity -casadi__SX__getSparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getSparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getSparsity :: SXClass a => a -> IO Sparsity -sx_getSparsity x = casadi__SX__getSparsity (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getSym" c_casadi__SX__getSym - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SX__getSym - :: SX -> Vector Double -> IO () -casadi__SX__getSym x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getSym errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getSym :: SXClass a => a -> Vector Double -> IO () -sx_getSym x = casadi__SX__getSym (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getValue__0" c_casadi__SX__getValue__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CDouble -casadi__SX__getValue__0 - :: SX -> Int -> IO Double -casadi__SX__getValue__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getValue__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getValue__0 :: SXClass a => a -> Int -> IO Double -sx_getValue__0 x = casadi__SX__getValue__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__getValue__1" c_casadi__SX__getValue__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CDouble -casadi__SX__getValue__1 - :: SX -> IO Double -casadi__SX__getValue__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__getValue__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_getValue__1 :: SXClass a => a -> IO Double -sx_getValue__1 x = casadi__SX__getValue__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__hasNZ" c_casadi__SX__hasNZ - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO CInt -casadi__SX__hasNZ - :: SX -> Int -> Int -> IO Bool -casadi__SX__hasNZ x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__hasNZ errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_hasNZ :: SXClass a => a -> Int -> Int -> IO Bool -sx_hasNZ x = casadi__SX__hasNZ (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__hasNonStructuralZeros" c_casadi__SX__hasNonStructuralZeros - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__hasNonStructuralZeros - :: SX -> IO Bool -casadi__SX__hasNonStructuralZeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__hasNonStructuralZeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_hasNonStructuralZeros :: SXClass a => a -> IO Bool -sx_hasNonStructuralZeros x = casadi__SX__hasNonStructuralZeros (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__inf__0" c_casadi__SX__inf__0 - :: Ptr (Ptr StdString) -> IO (Ptr SX') -casadi__SX__inf__0 - :: IO SX -casadi__SX__inf__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__inf__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_inf__0 :: IO SX -sx_inf__0 = casadi__SX__inf__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__inf__1" c_casadi__SX__inf__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') -casadi__SX__inf__1 - :: Int -> IO SX -casadi__SX__inf__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__inf__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_inf__1 :: Int -> IO SX -sx_inf__1 = casadi__SX__inf__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__inf__2" c_casadi__SX__inf__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__inf__2 - :: Int -> Int -> IO SX -casadi__SX__inf__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__inf__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_inf__2 :: Int -> Int -> IO SX -sx_inf__2 = casadi__SX__inf__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__inf__3" c_casadi__SX__inf__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__inf__3 - :: Sparsity -> IO SX -casadi__SX__inf__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__inf__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_inf__3 :: Sparsity -> IO SX -sx_inf__3 = casadi__SX__inf__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isCommutative" c_casadi__SX__isCommutative - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isCommutative - :: SX -> IO Bool -casadi__SX__isCommutative x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isCommutative errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isCommutative :: SXClass a => a -> IO Bool -sx_isCommutative x = casadi__SX__isCommutative (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isConstant" c_casadi__SX__isConstant - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isConstant - :: SX -> IO Bool -casadi__SX__isConstant x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isConstant errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__isDense" c_casadi__SX__isDense - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isDense - :: SX -> IO Bool -casadi__SX__isDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isDense :: SXClass a => a -> IO Bool -sx_isDense x = casadi__SX__isDense (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isEmpty__0" c_casadi__SX__isEmpty__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isEmpty__0 - :: SX -> IO Bool -casadi__SX__isEmpty__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isEmpty__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isEmpty__0 :: SXClass a => a -> IO Bool -sx_isEmpty__0 x = casadi__SX__isEmpty__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isEmpty__1" c_casadi__SX__isEmpty__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__isEmpty__1 - :: SX -> Bool -> IO Bool -casadi__SX__isEmpty__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isEmpty__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isEmpty__1 :: SXClass a => a -> Bool -> IO Bool -sx_isEmpty__1 x = casadi__SX__isEmpty__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isIdentity" c_casadi__SX__isIdentity - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isIdentity - :: SX -> IO Bool -casadi__SX__isIdentity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isIdentity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isIdentity :: SXClass a => a -> IO Bool -sx_isIdentity x = casadi__SX__isIdentity (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isInteger" c_casadi__SX__isInteger - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isInteger - :: SX -> IO Bool -casadi__SX__isInteger x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isInteger errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__isLeaf" c_casadi__SX__isLeaf - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isLeaf - :: SX -> IO Bool -casadi__SX__isLeaf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isLeaf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isLeaf :: SXClass a => a -> IO Bool -sx_isLeaf x = casadi__SX__isLeaf (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isMinusOne" c_casadi__SX__isMinusOne - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isMinusOne - :: SX -> IO Bool -casadi__SX__isMinusOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isMinusOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__isOne" c_casadi__SX__isOne - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isOne - :: SX -> IO Bool -casadi__SX__isOne x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isOne errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__isRegular" c_casadi__SX__isRegular - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isRegular - :: SX -> IO Bool -casadi__SX__isRegular x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isRegular errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isRegular :: SXClass a => a -> IO Bool -sx_isRegular x = casadi__SX__isRegular (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isRowVector" c_casadi__SX__isRowVector - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isRowVector - :: SX -> IO Bool -casadi__SX__isRowVector x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isRowVector errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isRowVector :: SXClass a => a -> IO Bool -sx_isRowVector x = casadi__SX__isRowVector (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isScalar__0" c_casadi__SX__isScalar__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isScalar__0 - :: SX -> IO Bool -casadi__SX__isScalar__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isScalar__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isScalar__0 :: SXClass a => a -> IO Bool -sx_isScalar__0 x = casadi__SX__isScalar__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isScalar__1" c_casadi__SX__isScalar__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__isScalar__1 - :: SX -> Bool -> IO Bool -casadi__SX__isScalar__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isScalar__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isScalar__1 :: SXClass a => a -> Bool -> IO Bool -sx_isScalar__1 x = casadi__SX__isScalar__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isSlice__0" c_casadi__SX__isSlice__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isSlice__0 - :: SX -> IO Bool -casadi__SX__isSlice__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isSlice__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isSlice__0 :: SXClass a => a -> IO Bool -sx_isSlice__0 x = casadi__SX__isSlice__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isSlice__1" c_casadi__SX__isSlice__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__isSlice__1 - :: SX -> Bool -> IO Bool -casadi__SX__isSlice__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isSlice__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isSlice__1 :: SXClass a => a -> Bool -> IO Bool -sx_isSlice__1 x = casadi__SX__isSlice__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isSmooth" c_casadi__SX__isSmooth - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isSmooth - :: SX -> IO Bool -casadi__SX__isSmooth x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isSmooth errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isSmooth :: SXClass a => a -> IO Bool -sx_isSmooth x = casadi__SX__isSmooth (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isSquare" c_casadi__SX__isSquare - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isSquare - :: SX -> IO Bool -casadi__SX__isSquare x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isSquare errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isSquare :: SXClass a => a -> IO Bool -sx_isSquare x = casadi__SX__isSquare (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isSymbolic" c_casadi__SX__isSymbolic - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isSymbolic - :: SX -> IO Bool -casadi__SX__isSymbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isSymbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__isSymbolicSparse" c_casadi__SX__isSymbolicSparse - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isSymbolicSparse - :: SX -> IO Bool -casadi__SX__isSymbolicSparse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isSymbolicSparse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isSymbolicSparse :: SXClass a => a -> IO Bool -sx_isSymbolicSparse x = casadi__SX__isSymbolicSparse (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isTril" c_casadi__SX__isTril - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isTril - :: SX -> IO Bool -casadi__SX__isTril x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isTril errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isTril :: SXClass a => a -> IO Bool -sx_isTril x = casadi__SX__isTril (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isTriu" c_casadi__SX__isTriu - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isTriu - :: SX -> IO Bool -casadi__SX__isTriu x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isTriu errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isTriu :: SXClass a => a -> IO Bool -sx_isTriu x = casadi__SX__isTriu (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isVector__0" c_casadi__SX__isVector__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isVector__0 - :: SX -> IO Bool -casadi__SX__isVector__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isVector__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isVector__0 :: SXClass a => a -> IO Bool -sx_isVector__0 x = casadi__SX__isVector__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isVector__1" c_casadi__SX__isVector__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__isVector__1 - :: SX -> Bool -> IO Bool -casadi__SX__isVector__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isVector__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_isVector__1 :: SXClass a => a -> Bool -> IO Bool -sx_isVector__1 x = casadi__SX__isVector__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__isZero" c_casadi__SX__isZero - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__isZero - :: SX -> IO Bool -casadi__SX__isZero x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__isZero errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__makeSparse__0" c_casadi__SX__makeSparse__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__makeSparse__0 - :: SX -> IO () -casadi__SX__makeSparse__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__makeSparse__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_makeSparse__0 :: SXClass a => a -> IO () -sx_makeSparse__0 x = casadi__SX__makeSparse__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__makeSparse__1" c_casadi__SX__makeSparse__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () -casadi__SX__makeSparse__1 - :: SX -> Double -> IO () -casadi__SX__makeSparse__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__makeSparse__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_makeSparse__1 :: SXClass a => a -> Double -> IO () -sx_makeSparse__1 x = casadi__SX__makeSparse__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__matrix_matrix" c_casadi__SX__matrix_matrix - :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__matrix_matrix - :: Int -> SX -> SX -> IO SX -casadi__SX__matrix_matrix x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__matrix_matrix errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_matrix_matrix :: Int -> SX -> SX -> IO SX -sx_matrix_matrix = casadi__SX__matrix_matrix - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__matrix_scalar" c_casadi__SX__matrix_scalar - :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__matrix_scalar - :: Int -> SX -> SX -> IO SX -casadi__SX__matrix_scalar x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__matrix_scalar errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_matrix_scalar :: Int -> SX -> SX -> IO SX -sx_matrix_scalar = casadi__SX__matrix_scalar - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__nan__0" c_casadi__SX__nan__0 - :: Ptr (Ptr StdString) -> IO (Ptr SX') -casadi__SX__nan__0 - :: IO SX -casadi__SX__nan__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__nan__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_nan__0 :: IO SX -sx_nan__0 = casadi__SX__nan__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__nan__1" c_casadi__SX__nan__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') -casadi__SX__nan__1 - :: Int -> IO SX -casadi__SX__nan__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__nan__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_nan__1 :: Int -> IO SX -sx_nan__1 = casadi__SX__nan__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__nan__2" c_casadi__SX__nan__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__nan__2 - :: Int -> Int -> IO SX -casadi__SX__nan__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__nan__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_nan__2 :: Int -> Int -> IO SX -sx_nan__2 = casadi__SX__nan__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__nan__3" c_casadi__SX__nan__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__nan__3 - :: Sparsity -> IO SX -casadi__SX__nan__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__nan__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_nan__3 :: Sparsity -> IO SX -sx_nan__3 = casadi__SX__nan__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__nnz" c_casadi__SX__nnz - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__nnz - :: SX -> IO Int -casadi__SX__nnz x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__nnz errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_nnz :: SXClass a => a -> IO Int -sx_nnz x = casadi__SX__nnz (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__nonzeros" c_casadi__SX__nonzeros - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CDouble)) -casadi__SX__nonzeros - :: SX -> IO (Vector Double) -casadi__SX__nonzeros x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__nonzeros errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_nonzeros :: SXClass a => a -> IO (Vector Double) -sx_nonzeros x = casadi__SX__nonzeros (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__nonzeros_int" c_casadi__SX__nonzeros_int - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) -casadi__SX__nonzeros_int - :: SX -> IO (Vector Int) -casadi__SX__nonzeros_int x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__nonzeros_int errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_nonzeros_int :: SXClass a => a -> IO (Vector Int) -sx_nonzeros_int x = casadi__SX__nonzeros_int (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__numel__0" c_casadi__SX__numel__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__numel__0 - :: SX -> Int -> IO Int -casadi__SX__numel__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__numel__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_numel__0 :: SXClass a => a -> Int -> IO Int -sx_numel__0 x = casadi__SX__numel__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__numel__1" c_casadi__SX__numel__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__numel__1 - :: SX -> IO Int -casadi__SX__numel__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__numel__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_numel__1 :: SXClass a => a -> IO Int -sx_numel__1 x = casadi__SX__numel__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__ones__0" c_casadi__SX__ones__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__ones__0 - :: Sparsity -> IO SX -casadi__SX__ones__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__ones__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_ones__0 :: Sparsity -> IO SX -sx_ones__0 = casadi__SX__ones__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__ones__1" c_casadi__SX__ones__1 - :: Ptr (Ptr StdString) -> IO (Ptr SX') -casadi__SX__ones__1 - :: IO SX -casadi__SX__ones__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__ones__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_ones__1 :: IO SX -sx_ones__1 = casadi__SX__ones__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__ones__2" c_casadi__SX__ones__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') -casadi__SX__ones__2 - :: Int -> IO SX -casadi__SX__ones__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__ones__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_ones__2 :: Int -> IO SX -sx_ones__2 = casadi__SX__ones__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__ones__3" c_casadi__SX__ones__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__ones__3 - :: Int -> Int -> IO SX -casadi__SX__ones__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__ones__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_ones__3 :: Int -> Int -> IO SX -sx_ones__3 = casadi__SX__ones__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__operator_plus" c_casadi__SX__operator_plus - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__operator_plus - :: SX -> IO SX -casadi__SX__operator_plus x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__operator_plus errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_operator_plus :: SXClass a => a -> IO SX -sx_operator_plus x = casadi__SX__operator_plus (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__operator_minus" c_casadi__SX__operator_minus - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__operator_minus - :: SX -> IO SX -casadi__SX__operator_minus x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__operator_minus errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__printDense" c_casadi__SX__printDense - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__printDense - :: SX -> IO () -casadi__SX__printDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__printDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_printDense :: SXClass a => a -> IO () -sx_printDense x = casadi__SX__printDense (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__printScalar" c_casadi__SX__printScalar - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__printScalar - :: SX -> IO () -casadi__SX__printScalar x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__printScalar errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_printScalar :: SXClass a => a -> IO () -sx_printScalar x = casadi__SX__printScalar (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__printSparse" c_casadi__SX__printSparse - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__printSparse - :: SX -> IO () -casadi__SX__printSparse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__printSparse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_printSparse :: SXClass a => a -> IO () -sx_printSparse x = casadi__SX__printSparse (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__printVector" c_casadi__SX__printVector - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__printVector - :: SX -> IO () -casadi__SX__printVector x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__printVector errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_printVector :: SXClass a => a -> IO () -sx_printVector x = casadi__SX__printVector (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__printme" c_casadi__SX__printme - :: Ptr (Ptr StdString) -> 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' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__printme errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- 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__remove" c_casadi__SX__remove - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__SX__remove - :: SX -> Vector Int -> Vector Int -> IO () -casadi__SX__remove x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__remove errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_remove :: SXClass a => a -> Vector Int -> Vector Int -> IO () -sx_remove x = casadi__SX__remove (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__reserve__0" c_casadi__SX__reserve__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO () -casadi__SX__reserve__0 - :: SX -> Int -> Int -> IO () -casadi__SX__reserve__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__reserve__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_reserve__0 :: SXClass a => a -> Int -> Int -> IO () -sx_reserve__0 x = casadi__SX__reserve__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__reserve__1" c_casadi__SX__reserve__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO () -casadi__SX__reserve__1 - :: SX -> Int -> IO () -casadi__SX__reserve__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__reserve__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_reserve__1 :: SXClass a => a -> Int -> IO () -sx_reserve__1 x = casadi__SX__reserve__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__resize" c_casadi__SX__resize - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO () -casadi__SX__resize - :: SX -> Int -> Int -> IO () -casadi__SX__resize x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__resize errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_resize :: SXClass a => a -> Int -> Int -> IO () -sx_resize x = casadi__SX__resize (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__row" c_casadi__SX__row - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__row - :: SX -> Int -> IO Int -casadi__SX__row x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__row errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_row :: SXClass a => a -> Int -> IO Int -sx_row x = casadi__SX__row (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sanityCheck__0" c_casadi__SX__sanityCheck__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__sanityCheck__0 - :: SX -> IO () -casadi__SX__sanityCheck__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sanityCheck__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sanityCheck__0 :: SXClass a => a -> IO () -sx_sanityCheck__0 x = casadi__SX__sanityCheck__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sanityCheck__1" c_casadi__SX__sanityCheck__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO () -casadi__SX__sanityCheck__1 - :: SX -> Bool -> IO () -casadi__SX__sanityCheck__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sanityCheck__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sanityCheck__1 :: SXClass a => a -> Bool -> IO () -sx_sanityCheck__1 x = casadi__SX__sanityCheck__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__scalar_matrix" c_casadi__SX__scalar_matrix - :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__scalar_matrix - :: Int -> SX -> SX -> IO SX -casadi__SX__scalar_matrix x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__scalar_matrix errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_scalar_matrix :: Int -> SX -> SX -> IO SX -sx_scalar_matrix = casadi__SX__scalar_matrix - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__0" c_casadi__SX__set__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () -casadi__SX__set__0 - :: SX -> SX -> Bool -> IMatrix -> IMatrix -> IO () -casadi__SX__set__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IMatrix -> IO () -sx_set__0 x = casadi__SX__set__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__1" c_casadi__SX__set__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () -casadi__SX__set__1 - :: SX -> SX -> Bool -> IMatrix -> Slice -> IO () -casadi__SX__set__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__1 :: SXClass a => a -> SX -> Bool -> IMatrix -> Slice -> IO () -sx_set__1 x = casadi__SX__set__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__2" c_casadi__SX__set__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () -casadi__SX__set__2 - :: SX -> SX -> Bool -> Slice -> IMatrix -> IO () -casadi__SX__set__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__2 :: SXClass a => a -> SX -> Bool -> Slice -> IMatrix -> IO () -sx_set__2 x = casadi__SX__set__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__3" c_casadi__SX__set__3 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () -casadi__SX__set__3 - :: SX -> SX -> Bool -> Slice -> Slice -> IO () -casadi__SX__set__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__3 :: SXClass a => a -> SX -> Bool -> Slice -> Slice -> IO () -sx_set__3 x = casadi__SX__set__3 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__4" c_casadi__SX__set__4 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Sparsity' -> IO () -casadi__SX__set__4 - :: SX -> SX -> Bool -> Sparsity -> IO () -casadi__SX__set__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__4 :: SXClass a => a -> SX -> Bool -> Sparsity -> IO () -sx_set__4 x = casadi__SX__set__4 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__5" c_casadi__SX__set__5 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () -casadi__SX__set__5 - :: SX -> SX -> Bool -> IMatrix -> IO () -casadi__SX__set__5 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__5 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__5 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () -sx_set__5 x = casadi__SX__set__5 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__6" c_casadi__SX__set__6 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () -casadi__SX__set__6 - :: SX -> SX -> Bool -> Slice -> IO () -casadi__SX__set__6 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__6 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__6 :: SXClass a => a -> SX -> Bool -> Slice -> IO () -sx_set__6 x = casadi__SX__set__6 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__7" c_casadi__SX__set__7 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SX__set__7 - :: SX -> Vector Double -> IO () -casadi__SX__set__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__7 :: SXClass a => a -> Vector Double -> IO () -sx_set__7 x = casadi__SX__set__7 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__8" c_casadi__SX__set__8 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__SX__set__8 - :: SX -> Vector Double -> Bool -> IO () -casadi__SX__set__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__8 :: SXClass a => a -> Vector Double -> Bool -> IO () -sx_set__8 x = casadi__SX__set__8 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__9" c_casadi__SX__set__9 - :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () -casadi__SX__set__9 - :: SX -> Double -> IO () -casadi__SX__set__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__9 :: SXClass a => a -> Double -> IO () -sx_set__9 x = casadi__SX__set__9 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__set__10" c_casadi__SX__set__10 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO () -casadi__SX__set__10 - :: SX -> SX -> IO () -casadi__SX__set__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__set__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_set__10 :: SXClass a => a -> SX -> IO () -sx_set__10 x = casadi__SX__set__10 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__0" c_casadi__SX__setEqualityCheckingDepth__0 - :: Ptr (Ptr StdString) -> IO () -casadi__SX__setEqualityCheckingDepth__0 - :: IO () -casadi__SX__setEqualityCheckingDepth__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setEqualityCheckingDepth__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setEqualityCheckingDepth__0 :: IO () -sx_setEqualityCheckingDepth__0 = casadi__SX__setEqualityCheckingDepth__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__1" c_casadi__SX__setEqualityCheckingDepth__1 - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__SX__setEqualityCheckingDepth__1 - :: Int -> IO () -casadi__SX__setEqualityCheckingDepth__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setEqualityCheckingDepth__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setEqualityCheckingDepth__1 :: Int -> IO () -sx_setEqualityCheckingDepth__1 = casadi__SX__setEqualityCheckingDepth__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setMaxNumCallsInPrint__0" c_casadi__SX__setMaxNumCallsInPrint__0 - :: Ptr (Ptr StdString) -> IO () -casadi__SX__setMaxNumCallsInPrint__0 - :: IO () -casadi__SX__setMaxNumCallsInPrint__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setMaxNumCallsInPrint__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setMaxNumCallsInPrint__0 :: IO () -sx_setMaxNumCallsInPrint__0 = casadi__SX__setMaxNumCallsInPrint__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setMaxNumCallsInPrint__1" c_casadi__SX__setMaxNumCallsInPrint__1 - :: Ptr (Ptr StdString) -> CLong -> IO () -casadi__SX__setMaxNumCallsInPrint__1 - :: Int -> IO () -casadi__SX__setMaxNumCallsInPrint__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setMaxNumCallsInPrint__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setMaxNumCallsInPrint__1 :: Int -> IO () -sx_setMaxNumCallsInPrint__1 = casadi__SX__setMaxNumCallsInPrint__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setNZ__0" c_casadi__SX__setNZ__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () -casadi__SX__setNZ__0 - :: SX -> SX -> Bool -> IMatrix -> IO () -casadi__SX__setNZ__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setNZ__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setNZ__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () -sx_setNZ__0 x = casadi__SX__setNZ__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setNZ__1" c_casadi__SX__setNZ__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () -casadi__SX__setNZ__1 - :: SX -> SX -> Bool -> Slice -> IO () -casadi__SX__setNZ__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setNZ__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setNZ__1 :: SXClass a => a -> SX -> Bool -> Slice -> IO () -sx_setNZ__1 x = casadi__SX__setNZ__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setNZ__2" c_casadi__SX__setNZ__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SX__setNZ__2 - :: SX -> Vector Double -> IO () -casadi__SX__setNZ__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setNZ__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setNZ__2 :: SXClass a => a -> Vector Double -> IO () -sx_setNZ__2 x = casadi__SX__setNZ__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setNZ__3" c_casadi__SX__setNZ__3 - :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () -casadi__SX__setNZ__3 - :: SX -> Double -> IO () -casadi__SX__setNZ__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setNZ__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setNZ__3 :: SXClass a => a -> Double -> IO () -sx_setNZ__3 x = casadi__SX__setNZ__3 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setPrecision" c_casadi__SX__setPrecision - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__SX__setPrecision - :: Int -> IO () -casadi__SX__setPrecision x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setPrecision errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setPrecision :: Int -> IO () -sx_setPrecision = casadi__SX__setPrecision - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setScientific" c_casadi__SX__setScientific - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__SX__setScientific - :: Bool -> IO () -casadi__SX__setScientific x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setScientific errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setScientific :: Bool -> IO () -sx_setScientific = casadi__SX__setScientific - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setSparse__0" c_casadi__SX__setSparse__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__setSparse__0 - :: SX -> Sparsity -> IO SX -casadi__SX__setSparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setSparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setSparse__0 :: SXClass a => a -> Sparsity -> IO SX -sx_setSparse__0 x = casadi__SX__setSparse__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setSparse__1" c_casadi__SX__setSparse__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> CInt -> IO (Ptr SX') -casadi__SX__setSparse__1 - :: SX -> Sparsity -> Bool -> IO SX -casadi__SX__setSparse__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setSparse__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setSparse__1 :: SXClass a => a -> Sparsity -> Bool -> IO SX -sx_setSparse__1 x = casadi__SX__setSparse__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setSym" c_casadi__SX__setSym - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SX__setSym - :: SX -> Vector Double -> IO () -casadi__SX__setSym x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setSym errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setSym :: SXClass a => a -> Vector Double -> IO () -sx_setSym x = casadi__SX__setSym (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setValue__0" c_casadi__SX__setValue__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> CInt -> IO () -casadi__SX__setValue__0 - :: SX -> Double -> Int -> IO () -casadi__SX__setValue__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setValue__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setValue__0 :: SXClass a => a -> Double -> Int -> IO () -sx_setValue__0 x = casadi__SX__setValue__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setValue__1" c_casadi__SX__setValue__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () -casadi__SX__setValue__1 - :: SX -> Double -> IO () -casadi__SX__setValue__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setValue__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setValue__1 :: SXClass a => a -> Double -> IO () -sx_setValue__1 x = casadi__SX__setValue__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setWidth" c_casadi__SX__setWidth - :: Ptr (Ptr StdString) -> CInt -> IO () -casadi__SX__setWidth - :: Int -> IO () -casadi__SX__setWidth x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setWidth errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setWidth :: Int -> IO () -sx_setWidth = casadi__SX__setWidth - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__setZero" c_casadi__SX__setZero - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__setZero - :: SX -> IO () -casadi__SX__setZero x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__setZero errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_setZero :: SXClass a => a -> IO () -sx_setZero x = casadi__SX__setZero (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__size__0" c_casadi__SX__size__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt -casadi__SX__size__0 - :: SX -> SparsityType -> IO Int -casadi__SX__size__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__size__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_size__0 :: SXClass a => a -> SparsityType -> IO Int -sx_size__0 x = casadi__SX__size__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__size__1" c_casadi__SX__size__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__size__1 - :: SX -> IO Int -casadi__SX__size__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__size__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_size__1 :: SXClass a => a -> IO Int -sx_size__1 x = casadi__SX__size__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__size1" c_casadi__SX__size1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__size1 - :: SX -> IO Int -casadi__SX__size1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__size1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_size1 :: SXClass a => a -> IO Int -sx_size1 x = casadi__SX__size1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__size2" c_casadi__SX__size2 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__size2 - :: SX -> IO Int -casadi__SX__size2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__size2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_size2 :: SXClass a => a -> IO Int -sx_size2 x = casadi__SX__size2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sizeD" c_casadi__SX__sizeD - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__sizeD - :: SX -> IO Int -casadi__SX__sizeD x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sizeD errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sizeD :: SXClass a => a -> IO Int -sx_sizeD x = casadi__SX__sizeD (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sizeL" c_casadi__SX__sizeL - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__sizeL - :: SX -> IO Int -casadi__SX__sizeL x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sizeL errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sizeL :: SXClass a => a -> IO Int -sx_sizeL x = casadi__SX__sizeL (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sizeU" c_casadi__SX__sizeU - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__sizeU - :: SX -> IO Int -casadi__SX__sizeU x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sizeU errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sizeU :: SXClass a => a -> IO Int -sx_sizeU x = casadi__SX__sizeU (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sparse__0" c_casadi__SX__sparse__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__sparse__0 - :: Sparsity -> SX -> IO SX -casadi__SX__sparse__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sparse__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sparse__0 :: Sparsity -> SX -> IO SX -sx_sparse__0 = casadi__SX__sparse__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sparse__1" c_casadi__SX__sparse__1 - :: Ptr (Ptr StdString) -> IO (Ptr SX') -casadi__SX__sparse__1 - :: IO SX -casadi__SX__sparse__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sparse__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sparse__1 :: IO SX -sx_sparse__1 = casadi__SX__sparse__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sparse__2" c_casadi__SX__sparse__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') -casadi__SX__sparse__2 - :: Int -> IO SX -casadi__SX__sparse__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sparse__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sparse__2 :: Int -> IO SX -sx_sparse__2 = casadi__SX__sparse__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sparse__3" c_casadi__SX__sparse__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__sparse__3 - :: Int -> Int -> IO SX -casadi__SX__sparse__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sparse__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sparse__3 :: Int -> Int -> IO SX -sx_sparse__3 = casadi__SX__sparse__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sparsity" c_casadi__SX__sparsity - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity') -casadi__SX__sparsity - :: SX -> IO Sparsity -casadi__SX__sparsity x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sparsity errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sparsity :: SXClass a => a -> IO Sparsity -sx_sparsity x = casadi__SX__sparsity (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sparsityRef" c_casadi__SX__sparsityRef - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity') -casadi__SX__sparsityRef - :: SX -> IO Sparsity -casadi__SX__sparsityRef x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sparsityRef errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sparsityRef :: SXClass a => a -> IO Sparsity -sx_sparsityRef x = casadi__SX__sparsityRef (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__0" c_casadi__SX__sym__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -casadi__SX__sym__0 - :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX)) -casadi__SX__sym__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX)) -sx_sym__0 = casadi__SX__sym__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__1" c_casadi__SX__sym__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -casadi__SX__sym__1 - :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX)) -casadi__SX__sym__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX)) -sx_sym__1 = casadi__SX__sym__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__2" c_casadi__SX__sym__2 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__sym__2 - :: String -> Int -> Int -> Int -> IO (Vector SX) -casadi__SX__sym__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector SX) -sx_sym__2 = casadi__SX__sym__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__3" c_casadi__SX__sym__3 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__sym__3 - :: String -> Sparsity -> Int -> IO (Vector SX) -casadi__SX__sym__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__3 :: String -> Sparsity -> Int -> IO (Vector SX) -sx_sym__3 = casadi__SX__sym__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__4" c_casadi__SX__sym__4 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__sym__4 - :: String -> Sparsity -> IO SX -casadi__SX__sym__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__4 :: String -> Sparsity -> IO SX -sx_sym__4 = casadi__SX__sym__4 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__5" c_casadi__SX__sym__5 - :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr SX') -casadi__SX__sym__5 - :: String -> IO SX -casadi__SX__sym__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__5 :: String -> IO SX -sx_sym__5 = casadi__SX__sym__5 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__6" c_casadi__SX__sym__6 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr SX') -casadi__SX__sym__6 - :: String -> Int -> IO SX -casadi__SX__sym__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__6 :: String -> Int -> IO SX -sx_sym__6 = casadi__SX__sym__6 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__sym__7" c_casadi__SX__sym__7 - :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__sym__7 - :: String -> Int -> Int -> IO SX -casadi__SX__sym__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__sym__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_sym__7 :: String -> Int -> Int -> IO SX -sx_sym__7 = casadi__SX__sym__7 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__toSlice__0" c_casadi__SX__toSlice__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Slice') -casadi__SX__toSlice__0 - :: SX -> IO Slice -casadi__SX__toSlice__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__toSlice__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_toSlice__0 :: SXClass a => a -> IO Slice -sx_toSlice__0 x = casadi__SX__toSlice__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__toSlice__1" c_casadi__SX__toSlice__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr Slice') -casadi__SX__toSlice__1 - :: SX -> Bool -> IO Slice -casadi__SX__toSlice__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__toSlice__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_toSlice__1 :: SXClass a => a -> Bool -> IO Slice -sx_toSlice__1 x = casadi__SX__toSlice__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__triplet__0" c_casadi__SX__triplet__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__triplet__0 - :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX -casadi__SX__triplet__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__triplet__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_triplet__0 :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX -sx_triplet__0 = casadi__SX__triplet__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__triplet__1" c_casadi__SX__triplet__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__triplet__1 - :: Vector Int -> Vector Int -> SX -> IO SX -casadi__SX__triplet__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__triplet__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_triplet__1 :: Vector Int -> Vector Int -> SX -> IO SX -sx_triplet__1 = casadi__SX__triplet__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__unary" c_casadi__SX__unary - :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> IO (Ptr SX') -casadi__SX__unary - :: Int -> SX -> IO SX -casadi__SX__unary x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__unary errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_unary :: Int -> SX -> IO SX -sx_unary = casadi__SX__unary - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zeros__0" c_casadi__SX__zeros__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__zeros__0 - :: Sparsity -> IO SX -casadi__SX__zeros__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zeros__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zeros__0 :: Sparsity -> IO SX -sx_zeros__0 = casadi__SX__zeros__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zeros__1" c_casadi__SX__zeros__1 - :: Ptr (Ptr StdString) -> IO (Ptr SX') -casadi__SX__zeros__1 - :: IO SX -casadi__SX__zeros__1 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zeros__1 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zeros__1 :: IO SX -sx_zeros__1 = casadi__SX__zeros__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zeros__2" c_casadi__SX__zeros__2 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') -casadi__SX__zeros__2 - :: Int -> IO SX -casadi__SX__zeros__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zeros__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zeros__2 :: Int -> IO SX -sx_zeros__2 = casadi__SX__zeros__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zeros__3" c_casadi__SX__zeros__3 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__zeros__3 - :: Int -> Int -> IO SX -casadi__SX__zeros__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zeros__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zeros__3 :: Int -> Int -> IO SX -sx_zeros__3 = casadi__SX__zeros__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_abs" c_casadi__SX__zz_abs - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_abs - :: SX -> IO SX -casadi__SX__zz_abs x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_abs errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_abs :: SXClass a => a -> IO SX -sx_zz_abs x = casadi__SX__zz_abs (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_acos" c_casadi__SX__zz_acos - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_acos - :: SX -> IO SX -casadi__SX__zz_acos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_acos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_acos :: SXClass a => a -> IO SX -sx_zz_acos x = casadi__SX__zz_acos (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_acosh" c_casadi__SX__zz_acosh - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_acosh - :: SX -> IO SX -casadi__SX__zz_acosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_acosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_acosh :: SXClass a => a -> IO SX -sx_zz_acosh x = casadi__SX__zz_acosh (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_adj" c_casadi__SX__zz_adj - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_adj - :: SX -> IO SX -casadi__SX__zz_adj x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_adj errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_adj :: SXClass a => a -> IO SX -sx_zz_adj x = casadi__SX__zz_adj (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_all" c_casadi__SX__zz_all - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_all - :: SX -> IO SX -casadi__SX__zz_all x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_all errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_all :: SXClass a => a -> IO SX -sx_zz_all x = casadi__SX__zz_all (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_and" c_casadi__SX__zz_and - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_and - :: SX -> SX -> IO SX -casadi__SX__zz_and x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_and errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_and :: SXClass a => a -> SX -> IO SX -sx_zz_and x = casadi__SX__zz_and (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_any" c_casadi__SX__zz_any - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_any - :: SX -> IO SX -casadi__SX__zz_any x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_any errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_any :: SXClass a => a -> IO SX -sx_zz_any x = casadi__SX__zz_any (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_asin" c_casadi__SX__zz_asin - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_asin - :: SX -> IO SX -casadi__SX__zz_asin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_asin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_asin :: SXClass a => a -> IO SX -sx_zz_asin x = casadi__SX__zz_asin (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_asinh" c_casadi__SX__zz_asinh - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_asinh - :: SX -> IO SX -casadi__SX__zz_asinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_asinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_asinh :: SXClass a => a -> IO SX -sx_zz_asinh x = casadi__SX__zz_asinh (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_atan" c_casadi__SX__zz_atan - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_atan - :: SX -> IO SX -casadi__SX__zz_atan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_atan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_atan :: SXClass a => a -> IO SX -sx_zz_atan x = casadi__SX__zz_atan (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_atan2" c_casadi__SX__zz_atan2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_atan2 - :: SX -> SX -> IO SX -casadi__SX__zz_atan2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_atan2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_atan2 :: SXClass a => a -> SX -> IO SX -sx_zz_atan2 x = casadi__SX__zz_atan2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_atanh" c_casadi__SX__zz_atanh - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_atanh - :: SX -> IO SX -casadi__SX__zz_atanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_atanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_atanh :: SXClass a => a -> IO SX -sx_zz_atanh x = casadi__SX__zz_atanh (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_blockcat" c_casadi__SX__zz_blockcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO (Ptr SX') -casadi__SX__zz_blockcat - :: Vector (Vector SX) -> IO SX -casadi__SX__zz_blockcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_blockcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_blockcat :: Vector (Vector SX) -> IO SX -sx_zz_blockcat = casadi__SX__zz_blockcat - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_blocksplit" c_casadi__SX__zz_blocksplit - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) -casadi__SX__zz_blocksplit - :: SX -> Vector Int -> Vector Int -> IO (Vector (Vector SX)) -casadi__SX__zz_blocksplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_blocksplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_blocksplit :: SXClass a => a -> Vector Int -> Vector Int -> IO (Vector (Vector SX)) -sx_zz_blocksplit x = casadi__SX__zz_blocksplit (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_ceil" c_casadi__SX__zz_ceil - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_ceil - :: SX -> IO SX -casadi__SX__zz_ceil x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_ceil errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_ceil :: SXClass a => a -> IO SX -sx_zz_ceil x = casadi__SX__zz_ceil (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_cofactor" c_casadi__SX__zz_cofactor - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__zz_cofactor - :: SX -> Int -> Int -> IO SX -casadi__SX__zz_cofactor x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_cofactor errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_cofactor :: SXClass a => a -> Int -> Int -> IO SX -sx_zz_cofactor x = casadi__SX__zz_cofactor (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_cos" c_casadi__SX__zz_cos - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_cos - :: SX -> IO SX -casadi__SX__zz_cos x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_cos errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_cos :: SXClass a => a -> IO SX -sx_zz_cos x = casadi__SX__zz_cos (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_cosh" c_casadi__SX__zz_cosh - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_cosh - :: SX -> IO SX -casadi__SX__zz_cosh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_cosh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_cosh :: SXClass a => a -> IO SX -sx_zz_cosh x = casadi__SX__zz_cosh (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_countNodes" c_casadi__SX__zz_countNodes - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__zz_countNodes - :: SX -> IO Int -casadi__SX__zz_countNodes x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_countNodes errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_countNodes :: SXClass a => a -> IO Int -sx_zz_countNodes x = casadi__SX__zz_countNodes (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_cross__0" c_casadi__SX__zz_cross__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_cross__0 - :: SX -> SX -> IO SX -casadi__SX__zz_cross__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_cross__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_cross__0 :: SXClass a => a -> SX -> IO SX -sx_zz_cross__0 x = casadi__SX__zz_cross__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_cross__1" c_casadi__SX__zz_cross__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_cross__1 - :: SX -> SX -> Int -> IO SX -casadi__SX__zz_cross__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_cross__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_cross__1 :: SXClass a => a -> SX -> Int -> IO SX -sx_zz_cross__1 x = casadi__SX__zz_cross__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_densify" c_casadi__SX__zz_densify - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_densify - :: SX -> IO SX -casadi__SX__zz_densify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_densify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_densify :: SXClass a => a -> IO SX -sx_zz_densify x = casadi__SX__zz_densify (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_dependsOn" c_casadi__SX__zz_dependsOn - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt -casadi__SX__zz_dependsOn - :: SX -> SX -> IO Bool -casadi__SX__zz_dependsOn x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_dependsOn errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_dependsOn :: SXClass a => a -> SX -> IO Bool -sx_zz_dependsOn x = casadi__SX__zz_dependsOn (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_det" c_casadi__SX__zz_det - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_det - :: SX -> IO SX -casadi__SX__zz_det x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_det errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_det :: SXClass a => a -> IO SX -sx_zz_det x = casadi__SX__zz_det (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_diag" c_casadi__SX__zz_diag - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_diag - :: SX -> IO SX -casadi__SX__zz_diag x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_diag errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_diag :: SXClass a => a -> IO SX -sx_zz_diag x = casadi__SX__zz_diag (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_diagcat" c_casadi__SX__zz_diagcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') -casadi__SX__zz_diagcat - :: Vector SX -> IO SX -casadi__SX__zz_diagcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_diagcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_diagcat :: Vector SX -> IO SX -sx_zz_diagcat = casadi__SX__zz_diagcat - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_diagsplit" c_casadi__SX__zz_diagsplit - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__zz_diagsplit - :: SX -> Vector Int -> Vector Int -> IO (Vector SX) -casadi__SX__zz_diagsplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_diagsplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_diagsplit :: SXClass a => a -> Vector Int -> Vector Int -> IO (Vector SX) -sx_zz_diagsplit x = casadi__SX__zz_diagsplit (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_eig_symbolic" c_casadi__SX__zz_eig_symbolic - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_eig_symbolic - :: SX -> IO SX -casadi__SX__zz_eig_symbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_eig_symbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_eig_symbolic :: SXClass a => a -> IO SX -sx_zz_eig_symbolic x = casadi__SX__zz_eig_symbolic (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_eq" c_casadi__SX__zz_eq - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_eq - :: SX -> SX -> IO SX -casadi__SX__zz_eq x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_eq errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_eq :: SXClass a => a -> SX -> IO SX -sx_zz_eq x = casadi__SX__zz_eq (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_erf" c_casadi__SX__zz_erf - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_erf - :: SX -> IO SX -casadi__SX__zz_erf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_erf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_erf :: SXClass a => a -> IO SX -sx_zz_erf x = casadi__SX__zz_erf (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_erfinv" c_casadi__SX__zz_erfinv - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_erfinv - :: SX -> IO SX -casadi__SX__zz_erfinv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_erfinv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_erfinv :: SXClass a => a -> IO SX -sx_zz_erfinv x = casadi__SX__zz_erfinv (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_exp" c_casadi__SX__zz_exp - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_exp - :: SX -> IO SX -casadi__SX__zz_exp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_exp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_exp :: SXClass a => a -> IO SX -sx_zz_exp x = casadi__SX__zz_exp (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_expand" c_casadi__SX__zz_expand - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () -casadi__SX__zz_expand - :: SX -> SX -> SX -> IO () -casadi__SX__zz_expand x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_expand errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_expand :: SXClass a => a -> SX -> SX -> IO () -sx_zz_expand x = casadi__SX__zz_expand (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_extractShared__0" c_casadi__SX__zz_extractShared__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () -casadi__SX__zz_extractShared__0 - :: Vector SX -> Vector SX -> Vector SX -> IO () -casadi__SX__zz_extractShared__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_extractShared__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_extractShared__0 :: Vector SX -> Vector SX -> Vector SX -> IO () -sx_zz_extractShared__0 = casadi__SX__zz_extractShared__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_extractShared__1" c_casadi__SX__zz_extractShared__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO () -casadi__SX__zz_extractShared__1 - :: Vector SX -> Vector SX -> Vector SX -> String -> IO () -casadi__SX__zz_extractShared__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_extractShared__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_extractShared__1 :: Vector SX -> Vector SX -> Vector SX -> String -> IO () -sx_zz_extractShared__1 = casadi__SX__zz_extractShared__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_extractShared__2" c_casadi__SX__zz_extractShared__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO () -casadi__SX__zz_extractShared__2 - :: Vector SX -> Vector SX -> Vector SX -> String -> String -> IO () -casadi__SX__zz_extractShared__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_extractShared__2 :: Vector SX -> Vector SX -> Vector SX -> String -> String -> IO () -sx_zz_extractShared__2 = casadi__SX__zz_extractShared__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_floor" c_casadi__SX__zz_floor - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_floor - :: SX -> IO SX -casadi__SX__zz_floor x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_floor errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_floor :: SXClass a => a -> IO SX -sx_zz_floor x = casadi__SX__zz_floor (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_gauss_quadrature__0" c_casadi__SX__zz_gauss_quadrature__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_gauss_quadrature__0 - :: SX -> SX -> SX -> SX -> Int -> SX -> IO SX -casadi__SX__zz_gauss_quadrature__0 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_gauss_quadrature__0 :: SXClass a => a -> SX -> SX -> SX -> Int -> SX -> IO SX -sx_zz_gauss_quadrature__0 x = casadi__SX__zz_gauss_quadrature__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_gauss_quadrature__1" c_casadi__SX__zz_gauss_quadrature__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_gauss_quadrature__1 - :: SX -> SX -> SX -> SX -> IO SX -casadi__SX__zz_gauss_quadrature__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_gauss_quadrature__1 :: SXClass a => a -> SX -> SX -> SX -> IO SX -sx_zz_gauss_quadrature__1 x = casadi__SX__zz_gauss_quadrature__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_gauss_quadrature__2" c_casadi__SX__zz_gauss_quadrature__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_gauss_quadrature__2 - :: SX -> SX -> SX -> SX -> Int -> IO SX -casadi__SX__zz_gauss_quadrature__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_gauss_quadrature__2 :: SXClass a => a -> SX -> SX -> SX -> Int -> IO SX -sx_zz_gauss_quadrature__2 x = casadi__SX__zz_gauss_quadrature__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_ge" c_casadi__SX__zz_ge - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_ge - :: SX -> SX -> IO SX -casadi__SX__zz_ge x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_ge errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_ge :: SXClass a => a -> SX -> IO SX -sx_zz_ge x = casadi__SX__zz_ge (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_getMinor" c_casadi__SX__zz_getMinor - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__zz_getMinor - :: SX -> Int -> Int -> IO SX -casadi__SX__zz_getMinor x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_getMinor errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_getMinor :: SXClass a => a -> Int -> Int -> IO SX -sx_zz_getMinor x = casadi__SX__zz_getMinor (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_getOperatorRepresentation" c_casadi__SX__zz_getOperatorRepresentation - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) -casadi__SX__zz_getOperatorRepresentation - :: SX -> Vector String -> IO String -casadi__SX__zz_getOperatorRepresentation x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_getOperatorRepresentation errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_getOperatorRepresentation :: SXClass a => a -> Vector String -> IO String -sx_zz_getOperatorRepresentation x = casadi__SX__zz_getOperatorRepresentation (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_getSymbols__0" c_casadi__SX__zz_getSymbols__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__zz_getSymbols__0 - :: Vector SX -> IO (Vector SX) -casadi__SX__zz_getSymbols__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_getSymbols__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_getSymbols__0 :: Vector SX -> IO (Vector SX) -sx_zz_getSymbols__0 = casadi__SX__zz_getSymbols__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_getSymbols__1" c_casadi__SX__zz_getSymbols__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__zz_getSymbols__1 - :: SX -> IO (Vector SX) -casadi__SX__zz_getSymbols__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_getSymbols__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_getSymbols__1 :: SXClass a => a -> IO (Vector SX) -sx_zz_getSymbols__1 x = casadi__SX__zz_getSymbols__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_gradient" c_casadi__SX__zz_gradient - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_gradient - :: SX -> SX -> IO SX -casadi__SX__zz_gradient x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_gradient errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_gradient :: SXClass a => a -> SX -> IO SX -sx_zz_gradient x = casadi__SX__zz_gradient (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_gt" c_casadi__SX__zz_gt - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_gt - :: SX -> SX -> IO SX -casadi__SX__zz_gt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_gt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_gt :: SXClass a => a -> SX -> IO SX -sx_zz_gt x = casadi__SX__zz_gt (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_heaviside" c_casadi__SX__zz_heaviside - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_heaviside - :: SX -> IO SX -casadi__SX__zz_heaviside x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_heaviside errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_heaviside :: SXClass a => a -> IO SX -sx_zz_heaviside x = casadi__SX__zz_heaviside (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_hessian__0" c_casadi__SX__zz_hessian__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () -casadi__SX__zz_hessian__0 - :: SX -> SX -> SX -> SX -> IO () -casadi__SX__zz_hessian__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_hessian__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_hessian__0 :: SXClass a => a -> SX -> SX -> SX -> IO () -sx_zz_hessian__0 x = casadi__SX__zz_hessian__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_hessian__1" c_casadi__SX__zz_hessian__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_hessian__1 - :: SX -> SX -> IO SX -casadi__SX__zz_hessian__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_hessian__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_hessian__1 :: SXClass a => a -> SX -> IO SX -sx_zz_hessian__1 x = casadi__SX__zz_hessian__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_horzcat" c_casadi__SX__zz_horzcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') -casadi__SX__zz_horzcat - :: Vector SX -> IO SX -casadi__SX__zz_horzcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_horzcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_horzcat :: Vector SX -> IO SX -sx_zz_horzcat = casadi__SX__zz_horzcat - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_horzsplit" c_casadi__SX__zz_horzsplit - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__zz_horzsplit - :: SX -> Vector Int -> IO (Vector SX) -casadi__SX__zz_horzsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_horzsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_horzsplit :: SXClass a => a -> Vector Int -> IO (Vector SX) -sx_zz_horzsplit x = casadi__SX__zz_horzsplit (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_if_else" c_casadi__SX__zz_if_else - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_if_else - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_if_else x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_if_else errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_if_else :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_if_else x = casadi__SX__zz_if_else (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_if_else_zero" c_casadi__SX__zz_if_else_zero - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_if_else_zero - :: SX -> SX -> IO SX -casadi__SX__zz_if_else_zero x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_if_else_zero errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_if_else_zero :: SXClass a => a -> SX -> IO SX -sx_zz_if_else_zero x = casadi__SX__zz_if_else_zero (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_inner_prod" c_casadi__SX__zz_inner_prod - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_inner_prod - :: SX -> SX -> IO SX -casadi__SX__zz_inner_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_inner_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_inner_prod :: SXClass a => a -> SX -> IO SX -sx_zz_inner_prod x = casadi__SX__zz_inner_prod (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_inv" c_casadi__SX__zz_inv - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_inv - :: SX -> IO SX -casadi__SX__zz_inv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_inv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_inv :: SXClass a => a -> IO SX -sx_zz_inv x = casadi__SX__zz_inv (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_isEqual__0" c_casadi__SX__zz_isEqual__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt -casadi__SX__zz_isEqual__0 - :: SX -> SX -> IO Bool -casadi__SX__zz_isEqual__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_isEqual__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_isEqual__0 :: SXClass a => a -> SX -> IO Bool -sx_zz_isEqual__0 x = casadi__SX__zz_isEqual__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_isEqual__1" c_casadi__SX__zz_isEqual__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO CInt -casadi__SX__zz_isEqual__1 - :: SX -> SX -> Int -> IO Bool -casadi__SX__zz_isEqual__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_isEqual__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_isEqual__1 :: SXClass a => a -> SX -> Int -> IO Bool -sx_zz_isEqual__1 x = casadi__SX__zz_isEqual__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_jacobian" c_casadi__SX__zz_jacobian - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_jacobian - :: SX -> SX -> IO SX -casadi__SX__zz_jacobian x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_jacobian errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_jacobian :: SXClass a => a -> SX -> IO SX -sx_zz_jacobian x = casadi__SX__zz_jacobian (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_jacobianTimesVector__0" c_casadi__SX__zz_jacobianTimesVector__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_jacobianTimesVector__0 - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_jacobianTimesVector__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_jacobianTimesVector__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_jacobianTimesVector__0 :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_jacobianTimesVector__0 x = casadi__SX__zz_jacobianTimesVector__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_jacobianTimesVector__1" c_casadi__SX__zz_jacobianTimesVector__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_jacobianTimesVector__1 - :: SX -> SX -> SX -> Bool -> IO SX -casadi__SX__zz_jacobianTimesVector__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_jacobianTimesVector__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_jacobianTimesVector__1 :: SXClass a => a -> SX -> SX -> Bool -> IO SX -sx_zz_jacobianTimesVector__1 x = casadi__SX__zz_jacobianTimesVector__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_kron" c_casadi__SX__zz_kron - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_kron - :: SX -> SX -> IO SX -casadi__SX__zz_kron x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_kron errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_kron :: SXClass a => a -> SX -> IO SX -sx_zz_kron x = casadi__SX__zz_kron (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_le" c_casadi__SX__zz_le - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_le - :: SX -> SX -> IO SX -casadi__SX__zz_le x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_le errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_le :: SXClass a => a -> SX -> IO SX -sx_zz_le x = casadi__SX__zz_le (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_linspace" c_casadi__SX__zz_linspace - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_linspace - :: SX -> SX -> Int -> IO SX -casadi__SX__zz_linspace x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_linspace errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_linspace :: SXClass a => a -> SX -> Int -> IO SX -sx_zz_linspace x = casadi__SX__zz_linspace (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_log" c_casadi__SX__zz_log - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_log - :: SX -> IO SX -casadi__SX__zz_log x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_log errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_log :: SXClass a => a -> IO SX -sx_zz_log x = casadi__SX__zz_log (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_log10" c_casadi__SX__zz_log10 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_log10 - :: SX -> IO SX -casadi__SX__zz_log10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_log10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_log10 :: SXClass a => a -> IO SX -sx_zz_log10 x = casadi__SX__zz_log10 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_lt" c_casadi__SX__zz_lt - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_lt - :: SX -> SX -> IO SX -casadi__SX__zz_lt x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_lt errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_lt :: SXClass a => a -> SX -> IO SX -sx_zz_lt x = casadi__SX__zz_lt (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_max" c_casadi__SX__zz_max - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_max - :: SX -> SX -> IO SX -casadi__SX__zz_max x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_max errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_max :: SXClass a => a -> SX -> IO SX -sx_zz_max x = casadi__SX__zz_max (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_min" c_casadi__SX__zz_min - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_min - :: SX -> SX -> IO SX -casadi__SX__zz_min x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_min errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_min :: SXClass a => a -> SX -> IO SX -sx_zz_min x = casadi__SX__zz_min (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_minus" c_casadi__SX__zz_minus - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_minus - :: SX -> SX -> IO SX -casadi__SX__zz_minus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_minus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_minus :: SXClass a => a -> SX -> IO SX -sx_zz_minus x = casadi__SX__zz_minus (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_mod" c_casadi__SX__zz_mod - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_mod - :: SX -> SX -> IO SX -casadi__SX__zz_mod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_mod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_mod :: SXClass a => a -> SX -> IO SX -sx_zz_mod x = casadi__SX__zz_mod (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_mpower" c_casadi__SX__zz_mpower - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_mpower - :: SX -> SX -> IO SX -casadi__SX__zz_mpower x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_mpower errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_mpower :: SXClass a => a -> SX -> IO SX -sx_zz_mpower x = casadi__SX__zz_mpower (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_mtaylor__0" c_casadi__SX__zz_mtaylor__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr SX') -casadi__SX__zz_mtaylor__0 - :: SX -> SX -> SX -> Int -> Vector Int -> IO SX -casadi__SX__zz_mtaylor__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_mtaylor__0 :: SXClass a => a -> SX -> SX -> Int -> Vector Int -> IO SX -sx_zz_mtaylor__0 x = casadi__SX__zz_mtaylor__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_mtaylor__1" c_casadi__SX__zz_mtaylor__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_mtaylor__1 - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_mtaylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_mtaylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_mtaylor__1 :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_mtaylor__1 x = casadi__SX__zz_mtaylor__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_mtaylor__2" c_casadi__SX__zz_mtaylor__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_mtaylor__2 - :: SX -> SX -> SX -> Int -> IO SX -casadi__SX__zz_mtaylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_mtaylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_mtaylor__2 :: SXClass a => a -> SX -> SX -> Int -> IO SX -sx_zz_mtaylor__2 x = casadi__SX__zz_mtaylor__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_mtimes__0" c_casadi__SX__zz_mtimes__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_mtimes__0 - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_mtimes__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_mtimes__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_mtimes__0 :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_mtimes__0 x = casadi__SX__zz_mtimes__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_mtimes__1" c_casadi__SX__zz_mtimes__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_mtimes__1 - :: SX -> SX -> IO SX -casadi__SX__zz_mtimes__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_mtimes__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_mtimes__1 :: SXClass a => a -> SX -> IO SX -sx_zz_mtimes__1 x = casadi__SX__zz_mtimes__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_ne" c_casadi__SX__zz_ne - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_ne - :: SX -> SX -> IO SX -casadi__SX__zz_ne x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_ne errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_ne :: SXClass a => a -> SX -> IO SX -sx_zz_ne x = casadi__SX__zz_ne (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_norm_0_mul" c_casadi__SX__zz_norm_0_mul - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt -casadi__SX__zz_norm_0_mul - :: SX -> SX -> IO Int -casadi__SX__zz_norm_0_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_norm_0_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_norm_0_mul :: SXClass a => a -> SX -> IO Int -sx_zz_norm_0_mul x = casadi__SX__zz_norm_0_mul (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_norm_1" c_casadi__SX__zz_norm_1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_norm_1 - :: SX -> IO SX -casadi__SX__zz_norm_1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_norm_1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_norm_1 :: SXClass a => a -> IO SX -sx_zz_norm_1 x = casadi__SX__zz_norm_1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_norm_2" c_casadi__SX__zz_norm_2 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_norm_2 - :: SX -> IO SX -casadi__SX__zz_norm_2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_norm_2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_norm_2 :: SXClass a => a -> IO SX -sx_zz_norm_2 x = casadi__SX__zz_norm_2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_norm_F" c_casadi__SX__zz_norm_F - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_norm_F - :: SX -> IO SX -casadi__SX__zz_norm_F x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_norm_F errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_norm_F :: SXClass a => a -> IO SX -sx_zz_norm_F x = casadi__SX__zz_norm_F (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_norm_inf" c_casadi__SX__zz_norm_inf - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_norm_inf - :: SX -> IO SX -casadi__SX__zz_norm_inf x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_norm_inf errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_norm_inf :: SXClass a => a -> IO SX -sx_zz_norm_inf x = casadi__SX__zz_norm_inf (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_norm_inf_mul" c_casadi__SX__zz_norm_inf_mul - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_norm_inf_mul - :: SX -> SX -> IO SX -casadi__SX__zz_norm_inf_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_norm_inf_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_norm_inf_mul :: SXClass a => a -> SX -> IO SX -sx_zz_norm_inf_mul x = casadi__SX__zz_norm_inf_mul (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_not" c_casadi__SX__zz_not - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_not - :: SX -> IO SX -casadi__SX__zz_not x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_not errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_not :: SXClass a => a -> IO SX -sx_zz_not x = casadi__SX__zz_not (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_nullspace" c_casadi__SX__zz_nullspace - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_nullspace - :: SX -> IO SX -casadi__SX__zz_nullspace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_nullspace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_nullspace :: SXClass a => a -> IO SX -sx_zz_nullspace x = casadi__SX__zz_nullspace (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_or" c_casadi__SX__zz_or - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_or - :: SX -> SX -> IO SX -casadi__SX__zz_or x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_or errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_or :: SXClass a => a -> SX -> IO SX -sx_zz_or x = casadi__SX__zz_or (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_outer_prod" c_casadi__SX__zz_outer_prod - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_outer_prod - :: SX -> SX -> IO SX -casadi__SX__zz_outer_prod x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_outer_prod errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_outer_prod :: SXClass a => a -> SX -> IO SX -sx_zz_outer_prod x = casadi__SX__zz_outer_prod (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_pinv" c_casadi__SX__zz_pinv - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_pinv - :: SX -> IO SX -casadi__SX__zz_pinv x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_pinv errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_pinv :: SXClass a => a -> IO SX -sx_zz_pinv x = casadi__SX__zz_pinv (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_plus" c_casadi__SX__zz_plus - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_plus - :: SX -> SX -> IO SX -casadi__SX__zz_plus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_plus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_plus :: SXClass a => a -> SX -> IO SX -sx_zz_plus x = casadi__SX__zz_plus (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_poly_coeff" c_casadi__SX__zz_poly_coeff - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_poly_coeff - :: SX -> SX -> IO SX -casadi__SX__zz_poly_coeff x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_poly_coeff errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_poly_coeff :: SXClass a => a -> SX -> IO SX -sx_zz_poly_coeff x = casadi__SX__zz_poly_coeff (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_poly_roots" c_casadi__SX__zz_poly_roots - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_poly_roots - :: SX -> IO SX -casadi__SX__zz_poly_roots x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_poly_roots errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_poly_roots :: SXClass a => a -> IO SX -sx_zz_poly_roots x = casadi__SX__zz_poly_roots (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_polyval" c_casadi__SX__zz_polyval - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_polyval - :: SX -> SX -> IO SX -casadi__SX__zz_polyval x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_polyval errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_polyval :: SXClass a => a -> SX -> IO SX -sx_zz_polyval x = casadi__SX__zz_polyval (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_power" c_casadi__SX__zz_power - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_power - :: SX -> SX -> IO SX -casadi__SX__zz_power x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_power errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_power :: SXClass a => a -> SX -> IO SX -sx_zz_power x = casadi__SX__zz_power (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_printCompact" c_casadi__SX__zz_printCompact - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -casadi__SX__zz_printCompact - :: SX -> IO () -casadi__SX__zz_printCompact x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_printCompact errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_printCompact :: SXClass a => a -> IO () -sx_zz_printCompact x = casadi__SX__zz_printCompact (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_project" c_casadi__SX__zz_project - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__zz_project - :: SX -> Sparsity -> IO SX -casadi__SX__zz_project x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_project errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_project :: SXClass a => a -> Sparsity -> IO SX -sx_zz_project x = casadi__SX__zz_project (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_pw_const" c_casadi__SX__zz_pw_const - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_pw_const - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_pw_const x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_pw_const errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_pw_const :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_pw_const x = casadi__SX__zz_pw_const (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_pw_lin" c_casadi__SX__zz_pw_lin - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_pw_lin - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_pw_lin x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_pw_lin errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_pw_lin :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_pw_lin x = casadi__SX__zz_pw_lin (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_qr" c_casadi__SX__zz_qr - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () -casadi__SX__zz_qr - :: SX -> SX -> SX -> IO () -casadi__SX__zz_qr x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_qr errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_qr :: SXClass a => a -> SX -> SX -> IO () -sx_zz_qr x = casadi__SX__zz_qr (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_quad_form__0" c_casadi__SX__zz_quad_form__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_quad_form__0 - :: SX -> IO SX -casadi__SX__zz_quad_form__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_quad_form__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_quad_form__0 :: SXClass a => a -> IO SX -sx_zz_quad_form__0 x = casadi__SX__zz_quad_form__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_quad_form__1" c_casadi__SX__zz_quad_form__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_quad_form__1 - :: SX -> SX -> IO SX -casadi__SX__zz_quad_form__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_quad_form__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_quad_form__1 :: SXClass a => a -> SX -> IO SX -sx_zz_quad_form__1 x = casadi__SX__zz_quad_form__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_quad_form__2" c_casadi__SX__zz_quad_form__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_quad_form__2 - :: SX -> SX -> IO SX -casadi__SX__zz_quad_form__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_quad_form__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_quad_form__2 :: SXClass a => a -> SX -> IO SX -sx_zz_quad_form__2 x = casadi__SX__zz_quad_form__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_quad_form__3" c_casadi__SX__zz_quad_form__3 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_quad_form__3 - :: SX -> IO SX -casadi__SX__zz_quad_form__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_quad_form__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_quad_form__3 :: SXClass a => a -> IO SX -sx_zz_quad_form__3 x = casadi__SX__zz_quad_form__3 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_ramp" c_casadi__SX__zz_ramp - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_ramp - :: SX -> IO SX -casadi__SX__zz_ramp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_ramp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_ramp :: SXClass a => a -> IO SX -sx_zz_ramp x = casadi__SX__zz_ramp (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_rdivide" c_casadi__SX__zz_rdivide - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_rdivide - :: SX -> SX -> IO SX -casadi__SX__zz_rdivide x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_rdivide errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_rdivide :: SXClass a => a -> SX -> IO SX -sx_zz_rdivide x = casadi__SX__zz_rdivide (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_rectangle" c_casadi__SX__zz_rectangle - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_rectangle - :: SX -> IO SX -casadi__SX__zz_rectangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_rectangle errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_rectangle :: SXClass a => a -> IO SX -sx_zz_rectangle x = casadi__SX__zz_rectangle (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_repmat__0" c_casadi__SX__zz_repmat__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_repmat__0 - :: SX -> Int -> IO SX -casadi__SX__zz_repmat__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_repmat__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_repmat__0 :: SXClass a => a -> Int -> IO SX -sx_zz_repmat__0 x = casadi__SX__zz_repmat__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_repmat__1" c_casadi__SX__zz_repmat__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__zz_repmat__1 - :: SX -> Int -> Int -> IO SX -casadi__SX__zz_repmat__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_repmat__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_repmat__1 :: SXClass a => a -> Int -> Int -> IO SX -sx_zz_repmat__1 x = casadi__SX__zz_repmat__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_reshape__0" c_casadi__SX__zz_reshape__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') -casadi__SX__zz_reshape__0 - :: SX -> Sparsity -> IO SX -casadi__SX__zz_reshape__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_reshape__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_reshape__0 :: SXClass a => a -> Sparsity -> IO SX -sx_zz_reshape__0 x = casadi__SX__zz_reshape__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_reshape__1" c_casadi__SX__zz_reshape__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') -casadi__SX__zz_reshape__1 - :: SX -> Int -> Int -> IO SX -casadi__SX__zz_reshape__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_reshape__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_reshape__1 :: SXClass a => a -> Int -> Int -> IO SX -sx_zz_reshape__1 x = casadi__SX__zz_reshape__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sign" c_casadi__SX__zz_sign - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sign - :: SX -> IO SX -casadi__SX__zz_sign x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sign errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sign :: SXClass a => a -> IO SX -sx_zz_sign x = casadi__SX__zz_sign (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_simplify" c_casadi__SX__zz_simplify - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_simplify - :: SX -> IO SX -casadi__SX__zz_simplify x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_simplify errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_simplify :: SXClass a => a -> IO SX -sx_zz_simplify x = casadi__SX__zz_simplify (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sin" c_casadi__SX__zz_sin - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sin - :: SX -> IO SX -casadi__SX__zz_sin x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sin errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sin :: SXClass a => a -> IO SX -sx_zz_sin x = casadi__SX__zz_sin (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sinh" c_casadi__SX__zz_sinh - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sinh - :: SX -> IO SX -casadi__SX__zz_sinh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sinh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sinh :: SXClass a => a -> IO SX -sx_zz_sinh x = casadi__SX__zz_sinh (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_solve" c_casadi__SX__zz_solve - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_solve - :: SX -> SX -> IO SX -casadi__SX__zz_solve x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_solve errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_solve :: SXClass a => a -> SX -> IO SX -sx_zz_solve x = casadi__SX__zz_solve (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sparsify__0" c_casadi__SX__zz_sparsify__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sparsify__0 - :: SX -> IO SX -casadi__SX__zz_sparsify__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sparsify__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sparsify__0 :: SXClass a => a -> IO SX -sx_zz_sparsify__0 x = casadi__SX__zz_sparsify__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sparsify__1" c_casadi__SX__zz_sparsify__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO (Ptr SX') -casadi__SX__zz_sparsify__1 - :: SX -> Double -> IO SX -casadi__SX__zz_sparsify__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sparsify__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sparsify__1 :: SXClass a => a -> Double -> IO SX -sx_zz_sparsify__1 x = casadi__SX__zz_sparsify__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sprank" c_casadi__SX__zz_sprank - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -casadi__SX__zz_sprank - :: SX -> IO Int -casadi__SX__zz_sprank x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sprank errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sprank :: SXClass a => a -> IO Int -sx_zz_sprank x = casadi__SX__zz_sprank (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_spy" c_casadi__SX__zz_spy - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_spy - :: SX -> IO SX -casadi__SX__zz_spy x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_spy errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_spy :: SXClass a => a -> IO SX -sx_zz_spy x = casadi__SX__zz_spy (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sqrt" c_casadi__SX__zz_sqrt - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sqrt - :: SX -> IO SX -casadi__SX__zz_sqrt x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sqrt errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sqrt :: SXClass a => a -> IO SX -sx_zz_sqrt x = casadi__SX__zz_sqrt (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_substitute__0" c_casadi__SX__zz_substitute__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__zz_substitute__0 - :: Vector SX -> Vector SX -> Vector SX -> IO (Vector SX) -casadi__SX__zz_substitute__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_substitute__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_substitute__0 :: Vector SX -> Vector SX -> Vector SX -> IO (Vector SX) -sx_zz_substitute__0 = casadi__SX__zz_substitute__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_substitute__1" c_casadi__SX__zz_substitute__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_substitute__1 - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_substitute__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_substitute__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_substitute__1 :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_substitute__1 x = casadi__SX__zz_substitute__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_substituteInPlace__0" c_casadi__SX__zz_substituteInPlace__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () -casadi__SX__zz_substituteInPlace__0 - :: Vector SX -> Vector SX -> Vector SX -> IO () -casadi__SX__zz_substituteInPlace__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_substituteInPlace__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_substituteInPlace__0 :: Vector SX -> Vector SX -> Vector SX -> IO () -sx_zz_substituteInPlace__0 = casadi__SX__zz_substituteInPlace__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_substituteInPlace__1" c_casadi__SX__zz_substituteInPlace__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO () -casadi__SX__zz_substituteInPlace__1 - :: Vector SX -> Vector SX -> Vector SX -> Bool -> IO () -casadi__SX__zz_substituteInPlace__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_substituteInPlace__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_substituteInPlace__1 :: Vector SX -> Vector SX -> Vector SX -> Bool -> IO () -sx_zz_substituteInPlace__1 = casadi__SX__zz_substituteInPlace__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sumAll" c_casadi__SX__zz_sumAll - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sumAll - :: SX -> IO SX -casadi__SX__zz_sumAll x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sumAll errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sumAll :: SXClass a => a -> IO SX -sx_zz_sumAll x = casadi__SX__zz_sumAll (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sumCols" c_casadi__SX__zz_sumCols - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sumCols - :: SX -> IO SX -casadi__SX__zz_sumCols x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sumCols errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sumCols :: SXClass a => a -> IO SX -sx_zz_sumCols x = casadi__SX__zz_sumCols (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sumRows" c_casadi__SX__zz_sumRows - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sumRows - :: SX -> IO SX -casadi__SX__zz_sumRows x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sumRows errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sumRows :: SXClass a => a -> IO SX -sx_zz_sumRows x = casadi__SX__zz_sumRows (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_sum_square" c_casadi__SX__zz_sum_square - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_sum_square - :: SX -> IO SX -casadi__SX__zz_sum_square x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_sum_square errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_sum_square :: SXClass a => a -> IO SX -sx_zz_sum_square x = casadi__SX__zz_sum_square (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_tan" c_casadi__SX__zz_tan - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_tan - :: SX -> IO SX -casadi__SX__zz_tan x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_tan errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_tan :: SXClass a => a -> IO SX -sx_zz_tan x = casadi__SX__zz_tan (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_tangent" c_casadi__SX__zz_tangent - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_tangent - :: SX -> SX -> IO SX -casadi__SX__zz_tangent x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_tangent errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_tangent :: SXClass a => a -> SX -> IO SX -sx_zz_tangent x = casadi__SX__zz_tangent (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_tanh" c_casadi__SX__zz_tanh - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_tanh - :: SX -> IO SX -casadi__SX__zz_tanh x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_tanh errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_tanh :: SXClass a => a -> IO SX -sx_zz_tanh x = casadi__SX__zz_tanh (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_taylor__0" c_casadi__SX__zz_taylor__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_taylor__0 - :: SX -> SX -> IO SX -casadi__SX__zz_taylor__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_taylor__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_taylor__0 :: SXClass a => a -> SX -> IO SX -sx_zz_taylor__0 x = casadi__SX__zz_taylor__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_taylor__1" c_casadi__SX__zz_taylor__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_taylor__1 - :: SX -> SX -> SX -> IO SX -casadi__SX__zz_taylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_taylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_taylor__1 :: SXClass a => a -> SX -> SX -> IO SX -sx_zz_taylor__1 x = casadi__SX__zz_taylor__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_taylor__2" c_casadi__SX__zz_taylor__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_taylor__2 - :: SX -> SX -> SX -> Int -> IO SX -casadi__SX__zz_taylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_taylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_taylor__2 :: SXClass a => a -> SX -> SX -> Int -> IO SX -sx_zz_taylor__2 x = casadi__SX__zz_taylor__2 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_times" c_casadi__SX__zz_times - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_times - :: SX -> SX -> IO SX -casadi__SX__zz_times x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_times errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_times :: SXClass a => a -> SX -> IO SX -sx_zz_times x = casadi__SX__zz_times (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_trace" c_casadi__SX__zz_trace - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_trace - :: SX -> IO SX -casadi__SX__zz_trace x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_trace errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_trace :: SXClass a => a -> IO SX -sx_zz_trace x = casadi__SX__zz_trace (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_triangle" c_casadi__SX__zz_triangle - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_triangle - :: SX -> IO SX -casadi__SX__zz_triangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_triangle errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_triangle :: SXClass a => a -> IO SX -sx_zz_triangle x = casadi__SX__zz_triangle (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_tril__0" c_casadi__SX__zz_tril__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_tril__0 - :: SX -> IO SX -casadi__SX__zz_tril__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_tril__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_tril__0 :: SXClass a => a -> IO SX -sx_zz_tril__0 x = casadi__SX__zz_tril__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_tril__1" c_casadi__SX__zz_tril__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_tril__1 - :: SX -> Bool -> IO SX -casadi__SX__zz_tril__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_tril__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_tril__1 :: SXClass a => a -> Bool -> IO SX -sx_zz_tril__1 x = casadi__SX__zz_tril__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_tril2symm" c_casadi__SX__zz_tril2symm - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_tril2symm - :: SX -> IO SX -casadi__SX__zz_tril2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_tril2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_tril2symm :: SXClass a => a -> IO SX -sx_zz_tril2symm x = casadi__SX__zz_tril2symm (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_triu__0" c_casadi__SX__zz_triu__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_triu__0 - :: SX -> IO SX -casadi__SX__zz_triu__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_triu__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_triu__0 :: SXClass a => a -> IO SX -sx_zz_triu__0 x = casadi__SX__zz_triu__0 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_triu__1" c_casadi__SX__zz_triu__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') -casadi__SX__zz_triu__1 - :: SX -> Bool -> IO SX -casadi__SX__zz_triu__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_triu__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_triu__1 :: SXClass a => a -> Bool -> IO SX -sx_zz_triu__1 x = casadi__SX__zz_triu__1 (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_triu2symm" c_casadi__SX__zz_triu2symm - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_triu2symm - :: SX -> IO SX -casadi__SX__zz_triu2symm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_triu2symm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_triu2symm :: SXClass a => a -> IO SX -sx_zz_triu2symm x = casadi__SX__zz_triu2symm (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_unite" c_casadi__SX__zz_unite - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_unite - :: SX -> SX -> IO SX -casadi__SX__zz_unite x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_unite errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_unite :: SXClass a => a -> SX -> IO SX -sx_zz_unite x = casadi__SX__zz_unite (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_vec" c_casadi__SX__zz_vec - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_vec - :: SX -> IO SX -casadi__SX__zz_vec x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_vec errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_vec :: SXClass a => a -> IO SX -sx_zz_vec x = casadi__SX__zz_vec (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_vecNZ" c_casadi__SX__zz_vecNZ - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -casadi__SX__zz_vecNZ - :: SX -> IO SX -casadi__SX__zz_vecNZ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_vecNZ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_vecNZ :: SXClass a => a -> IO SX -sx_zz_vecNZ x = casadi__SX__zz_vecNZ (castSX x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_vecNZcat" c_casadi__SX__zz_vecNZcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') -casadi__SX__zz_vecNZcat - :: Vector SX -> IO SX -casadi__SX__zz_vecNZcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_vecNZcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_vecNZcat :: Vector SX -> IO SX -sx_zz_vecNZcat = casadi__SX__zz_vecNZcat - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_veccat" c_casadi__SX__zz_veccat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') -casadi__SX__zz_veccat - :: Vector SX -> IO SX -casadi__SX__zz_veccat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_veccat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_veccat :: Vector SX -> IO SX -sx_zz_veccat = casadi__SX__zz_veccat - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_vertcat" c_casadi__SX__zz_vertcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') -casadi__SX__zz_vertcat - :: Vector SX -> IO SX -casadi__SX__zz_vertcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_vertcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_vertcat :: Vector SX -> IO SX -sx_zz_vertcat = casadi__SX__zz_vertcat - - --- direct wrapper -foreign import ccall unsafe "casadi__SX__zz_vertsplit" c_casadi__SX__zz_vertsplit - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX'))) -casadi__SX__zz_vertsplit - :: SX -> Vector Int -> IO (Vector SX) -casadi__SX__zz_vertsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SX__zz_vertsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sx_zz_vertsplit :: SXClass a => a -> Vector Int -> IO (Vector SX) -sx_zz_vertsplit x = casadi__SX__zz_vertsplit (castSX x) + sx___nonzero__, + sx_append, + sx_appendColumns, + sx_binary, + sx_className, + sx_clear, + sx_colind, + sx_dimString, + sx_enlarge__0, + sx_enlarge__1, + sx_erase__0, + sx_erase__1, + sx_erase__2, + sx_erase__3, + sx_eye, + sx_find__0, + sx_find__1, + sx_getColind, + sx_getDep__0, + sx_getDep__1, + sx_getDescription, + sx_getElementHash, + sx_getEqualityCheckingDepth, + sx_getIntValue, + sx_getNZ__0, + sx_getNZ__1, + sx_getNZ__2, + sx_getName, + sx_getNdeps, + sx_getRepresentation, + sx_getRow, + sx_getSparsity, + sx_getSym, + sx_getValue__0, + sx_getValue__1, + sx_get__0, + sx_get__1, + sx_get__2, + sx_get__3, + sx_get__4, + sx_get__5, + sx_get__6, + sx_get__7, + sx_hasDuplicates, + sx_hasNZ, + sx_hasNonStructuralZeros, + sx_inf__0, + sx_inf__1, + sx_inf__2, + sx_inf__3, + sx_inf__4, + sx_isCommutative, + sx_isConstant, + sx_isIdentity, + sx_isInteger, + sx_isLeaf, + sx_isMinusOne, + sx_isOne, + sx_isRegular, + sx_isSlice__0, + sx_isSlice__1, + sx_isSmooth, + sx_isSymbolic, + sx_isValidInput, + sx_isZero, + sx_iscolumn, + sx_isdense, + sx_isempty__0, + sx_isempty__1, + sx_isrow, + sx_isscalar__0, + sx_isscalar__1, + sx_issquare, + sx_istril, + sx_istriu, + sx_isvector, + sx_makeSparse__0, + sx_makeSparse__1, + sx_matrix_matrix, + sx_matrix_scalar, + sx_nan__0, + sx_nan__1, + sx_nan__2, + sx_nan__3, + sx_nan__4, + sx_nnz, + sx_nonzeros, + sx_nonzeros_int, + sx_numel__0, + sx_numel__1, + sx_ones__0, + sx_ones__1, + sx_ones__2, + sx_ones__3, + sx_ones__4, + sx_operator_minus, + sx_operator_plus, + sx_printDense, + sx_printScalar, + sx_printSparse, + sx_printSplit, + sx_printVector, + sx_printme, + sx_remove, + sx_reserve__0, + sx_reserve__1, + sx_resetInput, + sx_resize, + sx_row, + sx_sanityCheck__0, + sx_sanityCheck__1, + sx_scalar_matrix, + sx_setEqualityCheckingDepth__0, + sx_setEqualityCheckingDepth__1, + sx_setNZ__0, + sx_setNZ__1, + sx_setNZ__2, + sx_setNZ__3, + sx_setPrecision, + sx_setScientific, + sx_setSym, + sx_setValue__0, + sx_setValue__1, + sx_setWidth, + sx_setZero, + sx_set__0, + sx_set__1, + sx_set__10, + sx_set__2, + sx_set__3, + sx_set__4, + sx_set__5, + sx_set__6, + sx_set__7, + sx_set__8, + sx_set__9, + sx_shape__0, + sx_shape__1, + sx_size, + sx_size1, + sx_size2, + sx_sizeD, + sx_sizeL, + sx_sizeU, + sx_sparse__0, + sx_sparse__1, + sx_sparse__2, + sx_sparse__3, + sx_sparse__4, + sx_sparsity, + sx_sym__0, + sx_sym__1, + sx_sym__2, + sx_sym__3, + sx_sym__4, + sx_sym__5, + sx_sym__6, + sx_sym__7, + sx_sym__8, + sx_toSlice__0, + sx_toSlice__1, + sx_triplet__0, + sx_triplet__1, + sx_triplet__2, + sx_unary, + sx_zeros__0, + sx_zeros__1, + sx_zeros__2, + sx_zeros__3, + sx_zeros__4, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__0" c_casadi__SX__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__0 + :: Vector Double -> IO SX +casadi__SX__CONSTRUCTOR__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__0 :: Vector Double -> IO SX +sx__0 = casadi__SX__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__1" c_casadi__SX__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__1 + :: DMatrix -> IO SX +casadi__SX__CONSTRUCTOR__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__1 :: DMatrix -> IO SX +sx__1 = casadi__SX__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__2" c_casadi__SX__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__2 + :: Vector Int -> IO SX +casadi__SX__CONSTRUCTOR__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__2 :: Vector Int -> IO SX +sx__2 = casadi__SX__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__3" c_casadi__SX__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__3 + :: IMatrix -> IO SX +casadi__SX__CONSTRUCTOR__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__3 :: IMatrix -> IO SX +sx__3 = casadi__SX__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__4" c_casadi__SX__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__4 + :: Vector (Vector Double) -> IO SX +casadi__SX__CONSTRUCTOR__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__4 :: Vector (Vector Double) -> IO SX +sx__4 = casadi__SX__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__5" c_casadi__SX__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> CDouble -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__5 + :: Double -> IO SX +casadi__SX__CONSTRUCTOR__5 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__5 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__5 :: Double -> IO SX +sx__5 = casadi__SX__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__6" c_casadi__SX__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr SX' -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__6 + :: Sparsity -> SX -> IO SX +casadi__SX__CONSTRUCTOR__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__6 :: Sparsity -> SX -> IO SX +sx__6 = casadi__SX__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__7" c_casadi__SX__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__7 + :: Sparsity -> IO SX +casadi__SX__CONSTRUCTOR__7 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__7 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__7 :: Sparsity -> IO SX +sx__7 = casadi__SX__CONSTRUCTOR__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__8" c_casadi__SX__CONSTRUCTOR__8 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__8 + :: Int -> Int -> IO SX +casadi__SX__CONSTRUCTOR__8 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__8 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__8 :: Int -> Int -> IO SX +sx__8 = casadi__SX__CONSTRUCTOR__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__9" c_casadi__SX__CONSTRUCTOR__9 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__9 + :: SX -> IO SX +casadi__SX__CONSTRUCTOR__9 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__9 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__9 :: SX -> IO SX +sx__9 = casadi__SX__CONSTRUCTOR__9 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__10" c_casadi__SX__CONSTRUCTOR__10 + :: Ptr (Ptr StdString) -> IO (Ptr SX') +casadi__SX__CONSTRUCTOR__10 + :: IO SX +casadi__SX__CONSTRUCTOR__10 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__CONSTRUCTOR__10 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx__10 :: IO SX +sx__10 = casadi__SX__CONSTRUCTOR__10 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__T" c_casadi__SX__T + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi__SX__T + :: SX -> IO SX +casadi__SX__T x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__T errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_T :: SXClass a => a -> IO SX +sx_T x = casadi__SX__T (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX____nonzero__" c_casadi__SX____nonzero__ + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX____nonzero__ + :: SX -> IO Bool +casadi__SX____nonzero__ x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX____nonzero__ errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx___nonzero__ :: SXClass a => a -> IO Bool +sx___nonzero__ x = casadi__SX____nonzero__ (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__append" c_casadi__SX__append + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO () +casadi__SX__append + :: SX -> SX -> IO () +casadi__SX__append x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__append errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_append :: SXClass a => a -> SX -> IO () +sx_append x = casadi__SX__append (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__appendColumns" c_casadi__SX__appendColumns + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO () +casadi__SX__appendColumns + :: SX -> SX -> IO () +casadi__SX__appendColumns x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__appendColumns errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_appendColumns :: SXClass a => a -> SX -> IO () +sx_appendColumns x = casadi__SX__appendColumns (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__binary" c_casadi__SX__binary + :: Ptr (Ptr StdString) -> 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' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__binary errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_binary :: Int -> SX -> SX -> IO SX +sx_binary = casadi__SX__binary + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__className" c_casadi__SX__className + :: Ptr (Ptr StdString) -> IO (Ptr StdString) +casadi__SX__className + :: IO String +casadi__SX__className = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__className errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_className :: IO String +sx_className = casadi__SX__className + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__clear" c_casadi__SX__clear + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__clear + :: SX -> IO () +casadi__SX__clear x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__clear errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_clear :: SXClass a => a -> IO () +sx_clear x = casadi__SX__clear (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__colind" c_casadi__SX__colind + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt +casadi__SX__colind + :: SX -> Int -> IO Int +casadi__SX__colind x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__colind errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_colind :: SXClass a => a -> Int -> IO Int +sx_colind x = casadi__SX__colind (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__dimString" c_casadi__SX__dimString + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString) +casadi__SX__dimString + :: SX -> IO String +casadi__SX__dimString x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__dimString errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_dimString :: SXClass a => a -> IO String +sx_dimString x = casadi__SX__dimString (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__enlarge__0" c_casadi__SX__enlarge__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__SX__enlarge__0 + :: SX -> Int -> Int -> Vector Int -> Vector Int -> IO () +casadi__SX__enlarge__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_enlarge__0 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () +sx_enlarge__0 x = casadi__SX__enlarge__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__enlarge__1" c_casadi__SX__enlarge__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__SX__enlarge__1 + :: SX -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +casadi__SX__enlarge__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_enlarge__1 :: SXClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +sx_enlarge__1 x = casadi__SX__enlarge__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__erase__0" c_casadi__SX__erase__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO () +casadi__SX__erase__0 + :: SX -> Vector Int -> IO () +casadi__SX__erase__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__erase__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_erase__0 :: SXClass a => a -> Vector Int -> IO () +sx_erase__0 x = casadi__SX__erase__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__erase__1" c_casadi__SX__erase__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__SX__erase__1 + :: SX -> Vector Int -> Bool -> IO () +casadi__SX__erase__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__erase__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_erase__1 :: SXClass a => a -> Vector Int -> Bool -> IO () +sx_erase__1 x = casadi__SX__erase__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__erase__2" c_casadi__SX__erase__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__SX__erase__2 + :: SX -> Vector Int -> Vector Int -> IO () +casadi__SX__erase__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__erase__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_erase__2 :: SXClass a => a -> Vector Int -> Vector Int -> IO () +sx_erase__2 x = casadi__SX__erase__2 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__erase__3" c_casadi__SX__erase__3 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__SX__erase__3 + :: SX -> Vector Int -> Vector Int -> Bool -> IO () +casadi__SX__erase__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__erase__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_erase__3 :: SXClass a => a -> Vector Int -> Vector Int -> Bool -> IO () +sx_erase__3 x = casadi__SX__erase__3 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__eye" c_casadi__SX__eye + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') +casadi__SX__eye + :: Int -> IO SX +casadi__SX__eye x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__eye errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_eye :: Int -> IO SX +sx_eye = casadi__SX__eye + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__find__0" c_casadi__SX__find__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) +casadi__SX__find__0 + :: SX -> IO (Vector Int) +casadi__SX__find__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__find__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_find__0 :: SXClass a => a -> IO (Vector Int) +sx_find__0 x = casadi__SX__find__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__find__1" c_casadi__SX__find__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec CInt)) +casadi__SX__find__1 + :: SX -> Bool -> IO (Vector Int) +casadi__SX__find__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__find__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_find__1 :: SXClass a => a -> Bool -> IO (Vector Int) +sx_find__1 x = casadi__SX__find__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__0" c_casadi__SX__get__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__SX__get__0 + :: SX -> SX -> Bool -> IMatrix -> IMatrix -> IO () +casadi__SX__get__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IMatrix -> IO () +sx_get__0 x = casadi__SX__get__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__1" c_casadi__SX__get__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__SX__get__1 + :: SX -> SX -> Bool -> IMatrix -> Slice -> IO () +casadi__SX__get__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__1 :: SXClass a => a -> SX -> Bool -> IMatrix -> Slice -> IO () +sx_get__1 x = casadi__SX__get__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__2" c_casadi__SX__get__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__SX__get__2 + :: SX -> SX -> Bool -> Slice -> IMatrix -> IO () +casadi__SX__get__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__2 :: SXClass a => a -> SX -> Bool -> Slice -> IMatrix -> IO () +sx_get__2 x = casadi__SX__get__2 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__3" c_casadi__SX__get__3 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__SX__get__3 + :: SX -> SX -> Bool -> Slice -> Slice -> IO () +casadi__SX__get__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__3 :: SXClass a => a -> SX -> Bool -> Slice -> Slice -> IO () +sx_get__3 x = casadi__SX__get__3 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__4" c_casadi__SX__get__4 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Sparsity' -> IO () +casadi__SX__get__4 + :: SX -> SX -> Bool -> Sparsity -> IO () +casadi__SX__get__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__4 :: SXClass a => a -> SX -> Bool -> Sparsity -> IO () +sx_get__4 x = casadi__SX__get__4 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__5" c_casadi__SX__get__5 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () +casadi__SX__get__5 + :: SX -> SX -> Bool -> IMatrix -> IO () +casadi__SX__get__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__5 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () +sx_get__5 x = casadi__SX__get__5 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__6" c_casadi__SX__get__6 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () +casadi__SX__get__6 + :: SX -> SX -> Bool -> Slice -> IO () +casadi__SX__get__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__6 :: SXClass a => a -> SX -> Bool -> Slice -> IO () +sx_get__6 x = casadi__SX__get__6 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__get__7" c_casadi__SX__get__7 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () +casadi__SX__get__7 + :: SX -> Vector Double -> IO () +casadi__SX__get__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__get__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_get__7 :: SXClass a => a -> Vector Double -> IO () +sx_get__7 x = casadi__SX__get__7 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getColind" c_casadi__SX__getColind + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) +casadi__SX__getColind + :: SX -> IO (Vector Int) +casadi__SX__getColind x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getColind errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getColind :: SXClass a => a -> IO (Vector Int) +sx_getColind x = casadi__SX__getColind (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getDep__0" c_casadi__SX__getDep__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi__SX__getDep__0 + :: SX -> IO SX +casadi__SX__getDep__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getDep__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getDep__0 :: SXClass a => a -> IO SX +sx_getDep__0 x = casadi__SX__getDep__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getDep__1" c_casadi__SX__getDep__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi__SX__getDep__1 + :: SX -> Int -> IO SX +casadi__SX__getDep__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getDep__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getDep__1 :: SXClass a => a -> Int -> IO SX +sx_getDep__1 x = casadi__SX__getDep__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getElementHash" c_casadi__SX__getElementHash + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CSize +casadi__SX__getElementHash + :: SX -> IO CSize +casadi__SX__getElementHash x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getElementHash errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getElementHash :: SXClass a => a -> IO CSize +sx_getElementHash x = casadi__SX__getElementHash (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getEqualityCheckingDepth" c_casadi__SX__getEqualityCheckingDepth + :: Ptr (Ptr StdString) -> IO CInt +casadi__SX__getEqualityCheckingDepth + :: IO Int +casadi__SX__getEqualityCheckingDepth = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getEqualityCheckingDepth errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getEqualityCheckingDepth :: IO Int +sx_getEqualityCheckingDepth = casadi__SX__getEqualityCheckingDepth + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getIntValue" c_casadi__SX__getIntValue + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__getIntValue + :: SX -> IO Int +casadi__SX__getIntValue x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getIntValue errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__getNZ__0" c_casadi__SX__getNZ__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () +casadi__SX__getNZ__0 + :: SX -> SX -> Bool -> IMatrix -> IO () +casadi__SX__getNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getNZ__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () +sx_getNZ__0 x = casadi__SX__getNZ__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getNZ__1" c_casadi__SX__getNZ__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () +casadi__SX__getNZ__1 + :: SX -> SX -> Bool -> Slice -> IO () +casadi__SX__getNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getNZ__1 :: SXClass a => a -> SX -> Bool -> Slice -> IO () +sx_getNZ__1 x = casadi__SX__getNZ__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getNZ__2" c_casadi__SX__getNZ__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () +casadi__SX__getNZ__2 + :: SX -> Vector Double -> IO () +casadi__SX__getNZ__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getNZ__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getNZ__2 :: SXClass a => a -> Vector Double -> IO () +sx_getNZ__2 x = casadi__SX__getNZ__2 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getName" c_casadi__SX__getName + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr StdString) +casadi__SX__getName + :: SX -> IO String +casadi__SX__getName x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getName errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getName :: SXClass a => a -> IO String +sx_getName x = casadi__SX__getName (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getNdeps" c_casadi__SX__getNdeps + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__getNdeps + :: SX -> IO Int +casadi__SX__getNdeps x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getNdeps errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getNdeps :: SXClass a => a -> IO Int +sx_getNdeps x = casadi__SX__getNdeps (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getRow" c_casadi__SX__getRow + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) +casadi__SX__getRow + :: SX -> IO (Vector Int) +casadi__SX__getRow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getRow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getRow :: SXClass a => a -> IO (Vector Int) +sx_getRow x = casadi__SX__getRow (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getSparsity" c_casadi__SX__getSparsity + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity') +casadi__SX__getSparsity + :: SX -> IO Sparsity +casadi__SX__getSparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getSparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getSparsity :: SXClass a => a -> IO Sparsity +sx_getSparsity x = casadi__SX__getSparsity (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getSym" c_casadi__SX__getSym + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () +casadi__SX__getSym + :: SX -> Vector Double -> IO () +casadi__SX__getSym x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getSym errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getSym :: SXClass a => a -> Vector Double -> IO () +sx_getSym x = casadi__SX__getSym (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getValue__0" c_casadi__SX__getValue__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CDouble +casadi__SX__getValue__0 + :: SX -> Int -> IO Double +casadi__SX__getValue__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getValue__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getValue__0 :: SXClass a => a -> Int -> IO Double +sx_getValue__0 x = casadi__SX__getValue__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__getValue__1" c_casadi__SX__getValue__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CDouble +casadi__SX__getValue__1 + :: SX -> IO Double +casadi__SX__getValue__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__getValue__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_getValue__1 :: SXClass a => a -> IO Double +sx_getValue__1 x = casadi__SX__getValue__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__hasDuplicates" c_casadi__SX__hasDuplicates + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__hasDuplicates + :: SX -> IO Bool +casadi__SX__hasDuplicates x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__hasDuplicates errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_hasDuplicates :: SXClass a => a -> IO Bool +sx_hasDuplicates x = casadi__SX__hasDuplicates (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__hasNZ" c_casadi__SX__hasNZ + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO CInt +casadi__SX__hasNZ + :: SX -> Int -> Int -> IO Bool +casadi__SX__hasNZ x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__hasNZ errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_hasNZ :: SXClass a => a -> Int -> Int -> IO Bool +sx_hasNZ x = casadi__SX__hasNZ (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__hasNonStructuralZeros" c_casadi__SX__hasNonStructuralZeros + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__hasNonStructuralZeros + :: SX -> IO Bool +casadi__SX__hasNonStructuralZeros x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__hasNonStructuralZeros errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_hasNonStructuralZeros :: SXClass a => a -> IO Bool +sx_hasNonStructuralZeros x = casadi__SX__hasNonStructuralZeros (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__inf__0" c_casadi__SX__inf__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi__SX__inf__0 + :: (Int, Int) -> IO SX +casadi__SX__inf__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__inf__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_inf__0 :: (Int, Int) -> IO SX +sx_inf__0 = casadi__SX__inf__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__inf__1" c_casadi__SX__inf__1 + :: Ptr (Ptr StdString) -> IO (Ptr SX') +casadi__SX__inf__1 + :: IO SX +casadi__SX__inf__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__inf__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_inf__1 :: IO SX +sx_inf__1 = casadi__SX__inf__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__inf__2" c_casadi__SX__inf__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') +casadi__SX__inf__2 + :: Int -> IO SX +casadi__SX__inf__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__inf__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_inf__2 :: Int -> IO SX +sx_inf__2 = casadi__SX__inf__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__inf__3" c_casadi__SX__inf__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__inf__3 + :: Int -> Int -> IO SX +casadi__SX__inf__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__inf__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_inf__3 :: Int -> Int -> IO SX +sx_inf__3 = casadi__SX__inf__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__inf__4" c_casadi__SX__inf__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') +casadi__SX__inf__4 + :: Sparsity -> IO SX +casadi__SX__inf__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__inf__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_inf__4 :: Sparsity -> IO SX +sx_inf__4 = casadi__SX__inf__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isCommutative" c_casadi__SX__isCommutative + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isCommutative + :: SX -> IO Bool +casadi__SX__isCommutative x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isCommutative errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isCommutative :: SXClass a => a -> IO Bool +sx_isCommutative x = casadi__SX__isCommutative (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isConstant" c_casadi__SX__isConstant + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isConstant + :: SX -> IO Bool +casadi__SX__isConstant x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isConstant errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__isIdentity" c_casadi__SX__isIdentity + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isIdentity + :: SX -> IO Bool +casadi__SX__isIdentity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isIdentity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isIdentity :: SXClass a => a -> IO Bool +sx_isIdentity x = casadi__SX__isIdentity (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isInteger" c_casadi__SX__isInteger + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isInteger + :: SX -> IO Bool +casadi__SX__isInteger x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isInteger errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__isLeaf" c_casadi__SX__isLeaf + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isLeaf + :: SX -> IO Bool +casadi__SX__isLeaf x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isLeaf errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isLeaf :: SXClass a => a -> IO Bool +sx_isLeaf x = casadi__SX__isLeaf (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isMinusOne" c_casadi__SX__isMinusOne + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isMinusOne + :: SX -> IO Bool +casadi__SX__isMinusOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isMinusOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__isOne" c_casadi__SX__isOne + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isOne + :: SX -> IO Bool +casadi__SX__isOne x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isOne errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__isRegular" c_casadi__SX__isRegular + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isRegular + :: SX -> IO Bool +casadi__SX__isRegular x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isRegular errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isRegular :: SXClass a => a -> IO Bool +sx_isRegular x = casadi__SX__isRegular (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isSlice__0" c_casadi__SX__isSlice__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isSlice__0 + :: SX -> IO Bool +casadi__SX__isSlice__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isSlice__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isSlice__0 :: SXClass a => a -> IO Bool +sx_isSlice__0 x = casadi__SX__isSlice__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isSlice__1" c_casadi__SX__isSlice__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt +casadi__SX__isSlice__1 + :: SX -> Bool -> IO Bool +casadi__SX__isSlice__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isSlice__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isSlice__1 :: SXClass a => a -> Bool -> IO Bool +sx_isSlice__1 x = casadi__SX__isSlice__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isSmooth" c_casadi__SX__isSmooth + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isSmooth + :: SX -> IO Bool +casadi__SX__isSmooth x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isSmooth errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isSmooth :: SXClass a => a -> IO Bool +sx_isSmooth x = casadi__SX__isSmooth (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isSymbolic" c_casadi__SX__isSymbolic + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isSymbolic + :: SX -> IO Bool +casadi__SX__isSymbolic x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isSymbolic errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__isValidInput" c_casadi__SX__isValidInput + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isValidInput + :: SX -> IO Bool +casadi__SX__isValidInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isValidInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isValidInput :: SXClass a => a -> IO Bool +sx_isValidInput x = casadi__SX__isValidInput (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isZero" c_casadi__SX__isZero + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isZero + :: SX -> IO Bool +casadi__SX__isZero x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isZero errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__iscolumn" c_casadi__SX__iscolumn + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__iscolumn + :: SX -> IO Bool +casadi__SX__iscolumn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__iscolumn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_iscolumn :: SXClass a => a -> IO Bool +sx_iscolumn x = casadi__SX__iscolumn (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isdense" c_casadi__SX__isdense + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isdense + :: SX -> IO Bool +casadi__SX__isdense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isdense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isdense :: SXClass a => a -> IO Bool +sx_isdense x = casadi__SX__isdense (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isempty__0" c_casadi__SX__isempty__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isempty__0 + :: SX -> IO Bool +casadi__SX__isempty__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isempty__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isempty__0 :: SXClass a => a -> IO Bool +sx_isempty__0 x = casadi__SX__isempty__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isempty__1" c_casadi__SX__isempty__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt +casadi__SX__isempty__1 + :: SX -> Bool -> IO Bool +casadi__SX__isempty__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isempty__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isempty__1 :: SXClass a => a -> Bool -> IO Bool +sx_isempty__1 x = casadi__SX__isempty__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isrow" c_casadi__SX__isrow + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isrow + :: SX -> IO Bool +casadi__SX__isrow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isrow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isrow :: SXClass a => a -> IO Bool +sx_isrow x = casadi__SX__isrow (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isscalar__0" c_casadi__SX__isscalar__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isscalar__0 + :: SX -> IO Bool +casadi__SX__isscalar__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isscalar__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isscalar__0 :: SXClass a => a -> IO Bool +sx_isscalar__0 x = casadi__SX__isscalar__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isscalar__1" c_casadi__SX__isscalar__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt +casadi__SX__isscalar__1 + :: SX -> Bool -> IO Bool +casadi__SX__isscalar__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isscalar__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isscalar__1 :: SXClass a => a -> Bool -> IO Bool +sx_isscalar__1 x = casadi__SX__isscalar__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__issquare" c_casadi__SX__issquare + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__issquare + :: SX -> IO Bool +casadi__SX__issquare x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__issquare errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_issquare :: SXClass a => a -> IO Bool +sx_issquare x = casadi__SX__issquare (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__istril" c_casadi__SX__istril + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__istril + :: SX -> IO Bool +casadi__SX__istril x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__istril errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_istril :: SXClass a => a -> IO Bool +sx_istril x = casadi__SX__istril (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__istriu" c_casadi__SX__istriu + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__istriu + :: SX -> IO Bool +casadi__SX__istriu x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__istriu errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_istriu :: SXClass a => a -> IO Bool +sx_istriu x = casadi__SX__istriu (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__isvector" c_casadi__SX__isvector + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__isvector + :: SX -> IO Bool +casadi__SX__isvector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__isvector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_isvector :: SXClass a => a -> IO Bool +sx_isvector x = casadi__SX__isvector (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__makeSparse__0" c_casadi__SX__makeSparse__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__makeSparse__0 + :: SX -> IO () +casadi__SX__makeSparse__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__makeSparse__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_makeSparse__0 :: SXClass a => a -> IO () +sx_makeSparse__0 x = casadi__SX__makeSparse__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__makeSparse__1" c_casadi__SX__makeSparse__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () +casadi__SX__makeSparse__1 + :: SX -> Double -> IO () +casadi__SX__makeSparse__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__makeSparse__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_makeSparse__1 :: SXClass a => a -> Double -> IO () +sx_makeSparse__1 x = casadi__SX__makeSparse__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__matrix_matrix" c_casadi__SX__matrix_matrix + :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi__SX__matrix_matrix + :: Int -> SX -> SX -> IO SX +casadi__SX__matrix_matrix x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__matrix_matrix errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_matrix_matrix :: Int -> SX -> SX -> IO SX +sx_matrix_matrix = casadi__SX__matrix_matrix + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__matrix_scalar" c_casadi__SX__matrix_scalar + :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi__SX__matrix_scalar + :: Int -> SX -> SX -> IO SX +casadi__SX__matrix_scalar x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__matrix_scalar errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_matrix_scalar :: Int -> SX -> SX -> IO SX +sx_matrix_scalar = casadi__SX__matrix_scalar + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nan__0" c_casadi__SX__nan__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi__SX__nan__0 + :: (Int, Int) -> IO SX +casadi__SX__nan__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nan__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nan__0 :: (Int, Int) -> IO SX +sx_nan__0 = casadi__SX__nan__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nan__1" c_casadi__SX__nan__1 + :: Ptr (Ptr StdString) -> IO (Ptr SX') +casadi__SX__nan__1 + :: IO SX +casadi__SX__nan__1 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nan__1 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nan__1 :: IO SX +sx_nan__1 = casadi__SX__nan__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nan__2" c_casadi__SX__nan__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') +casadi__SX__nan__2 + :: Int -> IO SX +casadi__SX__nan__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nan__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nan__2 :: Int -> IO SX +sx_nan__2 = casadi__SX__nan__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nan__3" c_casadi__SX__nan__3 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__nan__3 + :: Int -> Int -> IO SX +casadi__SX__nan__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nan__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nan__3 :: Int -> Int -> IO SX +sx_nan__3 = casadi__SX__nan__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nan__4" c_casadi__SX__nan__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') +casadi__SX__nan__4 + :: Sparsity -> IO SX +casadi__SX__nan__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nan__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nan__4 :: Sparsity -> IO SX +sx_nan__4 = casadi__SX__nan__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nnz" c_casadi__SX__nnz + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__nnz + :: SX -> IO Int +casadi__SX__nnz x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nnz errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nnz :: SXClass a => a -> IO Int +sx_nnz x = casadi__SX__nnz (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nonzeros" c_casadi__SX__nonzeros + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CDouble)) +casadi__SX__nonzeros + :: SX -> IO (Vector Double) +casadi__SX__nonzeros x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nonzeros errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nonzeros :: SXClass a => a -> IO (Vector Double) +sx_nonzeros x = casadi__SX__nonzeros (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__nonzeros_int" c_casadi__SX__nonzeros_int + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec CInt)) +casadi__SX__nonzeros_int + :: SX -> IO (Vector Int) +casadi__SX__nonzeros_int x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__nonzeros_int errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_nonzeros_int :: SXClass a => a -> IO (Vector Int) +sx_nonzeros_int x = casadi__SX__nonzeros_int (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__numel__0" c_casadi__SX__numel__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt +casadi__SX__numel__0 + :: SX -> Int -> IO Int +casadi__SX__numel__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__numel__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_numel__0 :: SXClass a => a -> Int -> IO Int +sx_numel__0 x = casadi__SX__numel__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__numel__1" c_casadi__SX__numel__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__numel__1 + :: SX -> IO Int +casadi__SX__numel__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__numel__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_numel__1 :: SXClass a => a -> IO Int +sx_numel__1 x = casadi__SX__numel__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__ones__0" c_casadi__SX__ones__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi__SX__ones__0 + :: (Int, Int) -> IO SX +casadi__SX__ones__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__ones__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_ones__0 :: (Int, Int) -> IO SX +sx_ones__0 = casadi__SX__ones__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__ones__1" c_casadi__SX__ones__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') +casadi__SX__ones__1 + :: Sparsity -> IO SX +casadi__SX__ones__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__ones__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_ones__1 :: Sparsity -> IO SX +sx_ones__1 = casadi__SX__ones__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__ones__2" c_casadi__SX__ones__2 + :: Ptr (Ptr StdString) -> IO (Ptr SX') +casadi__SX__ones__2 + :: IO SX +casadi__SX__ones__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__ones__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_ones__2 :: IO SX +sx_ones__2 = casadi__SX__ones__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__ones__3" c_casadi__SX__ones__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') +casadi__SX__ones__3 + :: Int -> IO SX +casadi__SX__ones__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__ones__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_ones__3 :: Int -> IO SX +sx_ones__3 = casadi__SX__ones__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__ones__4" c_casadi__SX__ones__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__ones__4 + :: Int -> Int -> IO SX +casadi__SX__ones__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__ones__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_ones__4 :: Int -> Int -> IO SX +sx_ones__4 = casadi__SX__ones__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__operator_plus" c_casadi__SX__operator_plus + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi__SX__operator_plus + :: SX -> IO SX +casadi__SX__operator_plus x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__operator_plus errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_operator_plus :: SXClass a => a -> IO SX +sx_operator_plus x = casadi__SX__operator_plus (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__operator_minus" c_casadi__SX__operator_minus + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi__SX__operator_minus + :: SX -> IO SX +casadi__SX__operator_minus x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__operator_minus errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__printDense" c_casadi__SX__printDense + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__printDense + :: SX -> IO () +casadi__SX__printDense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__printDense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_printDense :: SXClass a => a -> IO () +sx_printDense x = casadi__SX__printDense (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__printScalar" c_casadi__SX__printScalar + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__printScalar + :: SX -> IO () +casadi__SX__printScalar x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__printScalar errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_printScalar :: SXClass a => a -> IO () +sx_printScalar x = casadi__SX__printScalar (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__printSparse" c_casadi__SX__printSparse + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__printSparse + :: SX -> IO () +casadi__SX__printSparse x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__printSparse errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_printSparse :: SXClass a => a -> IO () +sx_printSparse x = casadi__SX__printSparse (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__printSplit" c_casadi__SX__printSplit + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO () +casadi__SX__printSplit + :: SX -> Vector String -> Vector String -> IO () +casadi__SX__printSplit x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__printSplit errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_printSplit :: SXClass a => a -> Vector String -> Vector String -> IO () +sx_printSplit x = casadi__SX__printSplit (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__printVector" c_casadi__SX__printVector + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__printVector + :: SX -> IO () +casadi__SX__printVector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__printVector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_printVector :: SXClass a => a -> IO () +sx_printVector x = casadi__SX__printVector (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__printme" c_casadi__SX__printme + :: Ptr (Ptr StdString) -> 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' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__printme errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- 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__remove" c_casadi__SX__remove + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__SX__remove + :: SX -> Vector Int -> Vector Int -> IO () +casadi__SX__remove x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__remove errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_remove :: SXClass a => a -> Vector Int -> Vector Int -> IO () +sx_remove x = casadi__SX__remove (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__reserve__0" c_casadi__SX__reserve__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO () +casadi__SX__reserve__0 + :: SX -> Int -> Int -> IO () +casadi__SX__reserve__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__reserve__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_reserve__0 :: SXClass a => a -> Int -> Int -> IO () +sx_reserve__0 x = casadi__SX__reserve__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__reserve__1" c_casadi__SX__reserve__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO () +casadi__SX__reserve__1 + :: SX -> Int -> IO () +casadi__SX__reserve__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__reserve__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_reserve__1 :: SXClass a => a -> Int -> IO () +sx_reserve__1 x = casadi__SX__reserve__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__resetInput" c_casadi__SX__resetInput + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__resetInput + :: SX -> IO () +casadi__SX__resetInput x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__resetInput errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_resetInput :: SXClass a => a -> IO () +sx_resetInput x = casadi__SX__resetInput (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__resize" c_casadi__SX__resize + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO () +casadi__SX__resize + :: SX -> Int -> Int -> IO () +casadi__SX__resize x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__resize errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_resize :: SXClass a => a -> Int -> Int -> IO () +sx_resize x = casadi__SX__resize (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__row" c_casadi__SX__row + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt +casadi__SX__row + :: SX -> Int -> IO Int +casadi__SX__row x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__row errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_row :: SXClass a => a -> Int -> IO Int +sx_row x = casadi__SX__row (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sanityCheck__0" c_casadi__SX__sanityCheck__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__sanityCheck__0 + :: SX -> IO () +casadi__SX__sanityCheck__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sanityCheck__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sanityCheck__0 :: SXClass a => a -> IO () +sx_sanityCheck__0 x = casadi__SX__sanityCheck__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sanityCheck__1" c_casadi__SX__sanityCheck__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO () +casadi__SX__sanityCheck__1 + :: SX -> Bool -> IO () +casadi__SX__sanityCheck__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sanityCheck__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sanityCheck__1 :: SXClass a => a -> Bool -> IO () +sx_sanityCheck__1 x = casadi__SX__sanityCheck__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__scalar_matrix" c_casadi__SX__scalar_matrix + :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi__SX__scalar_matrix + :: Int -> SX -> SX -> IO SX +casadi__SX__scalar_matrix x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__scalar_matrix errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_scalar_matrix :: Int -> SX -> SX -> IO SX +sx_scalar_matrix = casadi__SX__scalar_matrix + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__0" c_casadi__SX__set__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi__SX__set__0 + :: SX -> SX -> Bool -> IMatrix -> IMatrix -> IO () +casadi__SX__set__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IMatrix -> IO () +sx_set__0 x = casadi__SX__set__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__1" c_casadi__SX__set__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> Ptr Slice' -> IO () +casadi__SX__set__1 + :: SX -> SX -> Bool -> IMatrix -> Slice -> IO () +casadi__SX__set__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__1 :: SXClass a => a -> SX -> Bool -> IMatrix -> Slice -> IO () +sx_set__1 x = casadi__SX__set__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__2" c_casadi__SX__set__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr IMatrix' -> IO () +casadi__SX__set__2 + :: SX -> SX -> Bool -> Slice -> IMatrix -> IO () +casadi__SX__set__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__2 :: SXClass a => a -> SX -> Bool -> Slice -> IMatrix -> IO () +sx_set__2 x = casadi__SX__set__2 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__3" c_casadi__SX__set__3 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> Ptr Slice' -> IO () +casadi__SX__set__3 + :: SX -> SX -> Bool -> Slice -> Slice -> IO () +casadi__SX__set__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__3 :: SXClass a => a -> SX -> Bool -> Slice -> Slice -> IO () +sx_set__3 x = casadi__SX__set__3 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__4" c_casadi__SX__set__4 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Sparsity' -> IO () +casadi__SX__set__4 + :: SX -> SX -> Bool -> Sparsity -> IO () +casadi__SX__set__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__4 :: SXClass a => a -> SX -> Bool -> Sparsity -> IO () +sx_set__4 x = casadi__SX__set__4 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__5" c_casadi__SX__set__5 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () +casadi__SX__set__5 + :: SX -> SX -> Bool -> IMatrix -> IO () +casadi__SX__set__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__5 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () +sx_set__5 x = casadi__SX__set__5 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__6" c_casadi__SX__set__6 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () +casadi__SX__set__6 + :: SX -> SX -> Bool -> Slice -> IO () +casadi__SX__set__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__6 :: SXClass a => a -> SX -> Bool -> Slice -> IO () +sx_set__6 x = casadi__SX__set__6 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__7" c_casadi__SX__set__7 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () +casadi__SX__set__7 + :: SX -> Vector Double -> IO () +casadi__SX__set__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__7 :: SXClass a => a -> Vector Double -> IO () +sx_set__7 x = casadi__SX__set__7 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__8" c_casadi__SX__set__8 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO () +casadi__SX__set__8 + :: SX -> Vector Double -> Bool -> IO () +casadi__SX__set__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__8 :: SXClass a => a -> Vector Double -> Bool -> IO () +sx_set__8 x = casadi__SX__set__8 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__9" c_casadi__SX__set__9 + :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () +casadi__SX__set__9 + :: SX -> Double -> IO () +casadi__SX__set__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__9 :: SXClass a => a -> Double -> IO () +sx_set__9 x = casadi__SX__set__9 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__set__10" c_casadi__SX__set__10 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO () +casadi__SX__set__10 + :: SX -> SX -> IO () +casadi__SX__set__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__set__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_set__10 :: SXClass a => a -> SX -> IO () +sx_set__10 x = casadi__SX__set__10 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__0" c_casadi__SX__setEqualityCheckingDepth__0 + :: Ptr (Ptr StdString) -> IO () +casadi__SX__setEqualityCheckingDepth__0 + :: IO () +casadi__SX__setEqualityCheckingDepth__0 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setEqualityCheckingDepth__0 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setEqualityCheckingDepth__0 :: IO () +sx_setEqualityCheckingDepth__0 = casadi__SX__setEqualityCheckingDepth__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setEqualityCheckingDepth__1" c_casadi__SX__setEqualityCheckingDepth__1 + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__SX__setEqualityCheckingDepth__1 + :: Int -> IO () +casadi__SX__setEqualityCheckingDepth__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setEqualityCheckingDepth__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setEqualityCheckingDepth__1 :: Int -> IO () +sx_setEqualityCheckingDepth__1 = casadi__SX__setEqualityCheckingDepth__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setNZ__0" c_casadi__SX__setNZ__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr IMatrix' -> IO () +casadi__SX__setNZ__0 + :: SX -> SX -> Bool -> IMatrix -> IO () +casadi__SX__setNZ__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setNZ__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setNZ__0 :: SXClass a => a -> SX -> Bool -> IMatrix -> IO () +sx_setNZ__0 x = casadi__SX__setNZ__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setNZ__1" c_casadi__SX__setNZ__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> Ptr Slice' -> IO () +casadi__SX__setNZ__1 + :: SX -> SX -> Bool -> Slice -> IO () +casadi__SX__setNZ__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setNZ__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setNZ__1 :: SXClass a => a -> SX -> Bool -> Slice -> IO () +sx_setNZ__1 x = casadi__SX__setNZ__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setNZ__2" c_casadi__SX__setNZ__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () +casadi__SX__setNZ__2 + :: SX -> Vector Double -> IO () +casadi__SX__setNZ__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setNZ__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setNZ__2 :: SXClass a => a -> Vector Double -> IO () +sx_setNZ__2 x = casadi__SX__setNZ__2 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setNZ__3" c_casadi__SX__setNZ__3 + :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () +casadi__SX__setNZ__3 + :: SX -> Double -> IO () +casadi__SX__setNZ__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setNZ__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setNZ__3 :: SXClass a => a -> Double -> IO () +sx_setNZ__3 x = casadi__SX__setNZ__3 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setPrecision" c_casadi__SX__setPrecision + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__SX__setPrecision + :: Int -> IO () +casadi__SX__setPrecision x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setPrecision errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setPrecision :: Int -> IO () +sx_setPrecision = casadi__SX__setPrecision + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setScientific" c_casadi__SX__setScientific + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__SX__setScientific + :: Bool -> IO () +casadi__SX__setScientific x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setScientific errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setScientific :: Bool -> IO () +sx_setScientific = casadi__SX__setScientific + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setSym" c_casadi__SX__setSym + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () +casadi__SX__setSym + :: SX -> Vector Double -> IO () +casadi__SX__setSym x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setSym errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setSym :: SXClass a => a -> Vector Double -> IO () +sx_setSym x = casadi__SX__setSym (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setValue__0" c_casadi__SX__setValue__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> CInt -> IO () +casadi__SX__setValue__0 + :: SX -> Double -> Int -> IO () +casadi__SX__setValue__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setValue__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setValue__0 :: SXClass a => a -> Double -> Int -> IO () +sx_setValue__0 x = casadi__SX__setValue__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setValue__1" c_casadi__SX__setValue__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO () +casadi__SX__setValue__1 + :: SX -> Double -> IO () +casadi__SX__setValue__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setValue__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setValue__1 :: SXClass a => a -> Double -> IO () +sx_setValue__1 x = casadi__SX__setValue__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setWidth" c_casadi__SX__setWidth + :: Ptr (Ptr StdString) -> CInt -> IO () +casadi__SX__setWidth + :: Int -> IO () +casadi__SX__setWidth x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setWidth errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setWidth :: Int -> IO () +sx_setWidth = casadi__SX__setWidth + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__setZero" c_casadi__SX__setZero + :: Ptr (Ptr StdString) -> Ptr SX' -> IO () +casadi__SX__setZero + :: SX -> IO () +casadi__SX__setZero x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__setZero errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_setZero :: SXClass a => a -> IO () +sx_setZero x = casadi__SX__setZero (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__shape__0" c_casadi__SX__shape__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO CInt +casadi__SX__shape__0 + :: SX -> Int -> IO Int +casadi__SX__shape__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__shape__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_shape__0 :: SXClass a => a -> Int -> IO Int +sx_shape__0 x = casadi__SX__shape__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__shape__1" c_casadi__SX__shape__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdPair CInt CInt)) +casadi__SX__shape__1 + :: SX -> IO (Int, Int) +casadi__SX__shape__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__shape__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_shape__1 :: SXClass a => a -> IO (Int, Int) +sx_shape__1 x = casadi__SX__shape__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__size" c_casadi__SX__size + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__size + :: SX -> IO Int +casadi__SX__size x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__size errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_size :: SXClass a => a -> IO Int +sx_size x = casadi__SX__size (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__size1" c_casadi__SX__size1 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__size1 + :: SX -> IO Int +casadi__SX__size1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__size1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_size1 :: SXClass a => a -> IO Int +sx_size1 x = casadi__SX__size1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__size2" c_casadi__SX__size2 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__size2 + :: SX -> IO Int +casadi__SX__size2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__size2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_size2 :: SXClass a => a -> IO Int +sx_size2 x = casadi__SX__size2 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sizeD" c_casadi__SX__sizeD + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__sizeD + :: SX -> IO Int +casadi__SX__sizeD x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sizeD errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sizeD :: SXClass a => a -> IO Int +sx_sizeD x = casadi__SX__sizeD (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sizeL" c_casadi__SX__sizeL + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__sizeL + :: SX -> IO Int +casadi__SX__sizeL x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sizeL errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sizeL :: SXClass a => a -> IO Int +sx_sizeL x = casadi__SX__sizeL (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sizeU" c_casadi__SX__sizeU + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi__SX__sizeU + :: SX -> IO Int +casadi__SX__sizeU x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sizeU errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sizeU :: SXClass a => a -> IO Int +sx_sizeU x = casadi__SX__sizeU (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sparse__0" c_casadi__SX__sparse__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr SX' -> IO (Ptr SX') +casadi__SX__sparse__0 + :: Sparsity -> SX -> IO SX +casadi__SX__sparse__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sparse__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sparse__0 :: Sparsity -> SX -> IO SX +sx_sparse__0 = casadi__SX__sparse__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sparse__1" c_casadi__SX__sparse__1 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi__SX__sparse__1 + :: (Int, Int) -> IO SX +casadi__SX__sparse__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sparse__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sparse__1 :: (Int, Int) -> IO SX +sx_sparse__1 = casadi__SX__sparse__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sparse__2" c_casadi__SX__sparse__2 + :: Ptr (Ptr StdString) -> IO (Ptr SX') +casadi__SX__sparse__2 + :: IO SX +casadi__SX__sparse__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sparse__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sparse__2 :: IO SX +sx_sparse__2 = casadi__SX__sparse__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sparse__3" c_casadi__SX__sparse__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') +casadi__SX__sparse__3 + :: Int -> IO SX +casadi__SX__sparse__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sparse__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sparse__3 :: Int -> IO SX +sx_sparse__3 = casadi__SX__sparse__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sparse__4" c_casadi__SX__sparse__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__sparse__4 + :: Int -> Int -> IO SX +casadi__SX__sparse__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sparse__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sparse__4 :: Int -> Int -> IO SX +sx_sparse__4 = casadi__SX__sparse__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sparsity" c_casadi__SX__sparsity + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Sparsity') +casadi__SX__sparsity + :: SX -> IO Sparsity +casadi__SX__sparsity x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sparsity errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sparsity :: SXClass a => a -> IO Sparsity +sx_sparsity x = casadi__SX__sparsity (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__0" c_casadi__SX__sym__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) +casadi__SX__sym__0 + :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX)) +casadi__SX__sym__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__0 :: String -> Int -> Int -> Int -> Int -> IO (Vector (Vector SX)) +sx_sym__0 = casadi__SX__sym__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__1" c_casadi__SX__sym__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) +casadi__SX__sym__1 + :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX)) +casadi__SX__sym__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__1 :: String -> Sparsity -> Int -> Int -> IO (Vector (Vector SX)) +sx_sym__1 = casadi__SX__sym__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__2" c_casadi__SX__sym__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi__SX__sym__2 + :: String -> Int -> Int -> Int -> IO (Vector SX) +casadi__SX__sym__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__2 :: String -> Int -> Int -> Int -> IO (Vector SX) +sx_sym__2 = casadi__SX__sym__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__3" c_casadi__SX__sym__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi__SX__sym__3 + :: String -> Sparsity -> Int -> IO (Vector SX) +casadi__SX__sym__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__3 :: String -> Sparsity -> Int -> IO (Vector SX) +sx_sym__3 = casadi__SX__sym__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__4" c_casadi__SX__sym__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr SX') +casadi__SX__sym__4 + :: String -> Sparsity -> IO SX +casadi__SX__sym__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__4 :: String -> Sparsity -> IO SX +sx_sym__4 = casadi__SX__sym__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__5" c_casadi__SX__sym__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi__SX__sym__5 + :: String -> (Int, Int) -> IO SX +casadi__SX__sym__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__5 :: String -> (Int, Int) -> IO SX +sx_sym__5 = casadi__SX__sym__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__6" c_casadi__SX__sym__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr SX') +casadi__SX__sym__6 + :: String -> IO SX +casadi__SX__sym__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__6 :: String -> IO SX +sx_sym__6 = casadi__SX__sym__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__7" c_casadi__SX__sym__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> IO (Ptr SX') +casadi__SX__sym__7 + :: String -> Int -> IO SX +casadi__SX__sym__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__7 :: String -> Int -> IO SX +sx_sym__7 = casadi__SX__sym__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__sym__8" c_casadi__SX__sym__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__sym__8 + :: String -> Int -> Int -> IO SX +casadi__SX__sym__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__sym__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_sym__8 :: String -> Int -> Int -> IO SX +sx_sym__8 = casadi__SX__sym__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__toSlice__0" c_casadi__SX__toSlice__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr Slice') +casadi__SX__toSlice__0 + :: SX -> IO Slice +casadi__SX__toSlice__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__toSlice__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_toSlice__0 :: SXClass a => a -> IO Slice +sx_toSlice__0 x = casadi__SX__toSlice__0 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__toSlice__1" c_casadi__SX__toSlice__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr Slice') +casadi__SX__toSlice__1 + :: SX -> Bool -> IO Slice +casadi__SX__toSlice__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__toSlice__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_toSlice__1 :: SXClass a => a -> Bool -> IO Slice +sx_toSlice__1 x = casadi__SX__toSlice__1 (castSX x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__triplet__0" c_casadi__SX__triplet__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi__SX__triplet__0 + :: Vector Int -> Vector Int -> SX -> (Int, Int) -> IO SX +casadi__SX__triplet__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__triplet__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_triplet__0 :: Vector Int -> Vector Int -> SX -> (Int, Int) -> IO SX +sx_triplet__0 = casadi__SX__triplet__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__triplet__1" c_casadi__SX__triplet__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__triplet__1 + :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX +casadi__SX__triplet__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__triplet__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_triplet__1 :: Vector Int -> Vector Int -> SX -> Int -> Int -> IO SX +sx_triplet__1 = casadi__SX__triplet__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__triplet__2" c_casadi__SX__triplet__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr SX' -> IO (Ptr SX') +casadi__SX__triplet__2 + :: Vector Int -> Vector Int -> SX -> IO SX +casadi__SX__triplet__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__triplet__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_triplet__2 :: Vector Int -> Vector Int -> SX -> IO SX +sx_triplet__2 = casadi__SX__triplet__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__unary" c_casadi__SX__unary + :: Ptr (Ptr StdString) -> CInt -> Ptr SX' -> IO (Ptr SX') +casadi__SX__unary + :: Int -> SX -> IO SX +casadi__SX__unary x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__unary errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_unary :: Int -> SX -> IO SX +sx_unary = casadi__SX__unary + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__zeros__0" c_casadi__SX__zeros__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi__SX__zeros__0 + :: (Int, Int) -> IO SX +casadi__SX__zeros__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__zeros__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_zeros__0 :: (Int, Int) -> IO SX +sx_zeros__0 = casadi__SX__zeros__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__zeros__1" c_casadi__SX__zeros__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr SX') +casadi__SX__zeros__1 + :: Sparsity -> IO SX +casadi__SX__zeros__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__zeros__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_zeros__1 :: Sparsity -> IO SX +sx_zeros__1 = casadi__SX__zeros__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__zeros__2" c_casadi__SX__zeros__2 + :: Ptr (Ptr StdString) -> IO (Ptr SX') +casadi__SX__zeros__2 + :: IO SX +casadi__SX__zeros__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__zeros__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_zeros__2 :: IO SX +sx_zeros__2 = casadi__SX__zeros__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__zeros__3" c_casadi__SX__zeros__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SX') +casadi__SX__zeros__3 + :: Int -> IO SX +casadi__SX__zeros__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__zeros__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_zeros__3 :: Int -> IO SX +sx_zeros__3 = casadi__SX__zeros__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SX__zeros__4" c_casadi__SX__zeros__4 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr SX') +casadi__SX__zeros__4 + :: Int -> Int -> IO SX +casadi__SX__zeros__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SX__zeros__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sx_zeros__4 :: Int -> Int -> IO SX +sx_zeros__4 = casadi__SX__zeros__4 -- direct wrapper diff --git a/Casadi/Core/Classes/SXElement.hs b/Casadi/Core/Classes/SXElement.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/SXElement.hs @@ -0,0 +1,31 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.SXElement + ( + SXElement, + SXElementClass(..), + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums diff --git a/Casadi/Core/Classes/SXFunction.hs b/Casadi/Core/Classes/SXFunction.hs --- a/Casadi/Core/Classes/SXFunction.hs +++ b/Casadi/Core/Classes/SXFunction.hs @@ -11,11 +11,19 @@ SXFunctionClass(..), sxFunction__0, sxFunction__1, + sxFunction__10, sxFunction__2, sxFunction__3, + sxFunction__4, + sxFunction__5, + sxFunction__6, + sxFunction__7, + sxFunction__8, + sxFunction__9, sxFunction_clearSymbolic, sxFunction_countNodes, sxFunction_getAlgorithmSize, + sxFunction_getAtomicInput, sxFunction_getAtomicInputReal, sxFunction_getAtomicOperation, sxFunction_getAtomicOutput, @@ -69,6 +77,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -76,92 +85,250 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__0" c_casadi__SXFunction__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SXFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr SXFunction') casadi__SXFunction__CONSTRUCTOR__0 - :: Vector SX -> Vector SX -> IO SXFunction -casadi__SXFunction__CONSTRUCTOR__0 x0 x1 = + :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__SXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__SXFunction__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -sxFunction__0 :: Vector SX -> Vector SX -> IO SXFunction +sxFunction__0 :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> IO SXFunction sxFunction__0 = casadi__SXFunction__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__1" c_casadi__SXFunction__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SXFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction') casadi__SXFunction__CONSTRUCTOR__1 - :: Function -> IO SXFunction -casadi__SXFunction__CONSTRUCTOR__1 x0 = + :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__SXFunction__CONSTRUCTOR__1 errStrPtrP x0' + ret <- c_casadi__SXFunction__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -sxFunction__1 :: Function -> IO SXFunction +sxFunction__1 :: String -> (M.Map String SX, Vector String) -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction sxFunction__1 = casadi__SXFunction__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__2" c_casadi__SXFunction__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr SXFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> IO (Ptr SXFunction') casadi__SXFunction__CONSTRUCTOR__2 - :: MXFunction -> IO SXFunction -casadi__SXFunction__CONSTRUCTOR__2 x0 = + :: String -> Vector SX -> (M.Map String SX, Vector String) -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__2 x0 x1 x2 = withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__SXFunction__CONSTRUCTOR__2 errStrPtrP x0' + ret <- c_casadi__SXFunction__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -sxFunction__2 :: MXFunction -> IO SXFunction +sxFunction__2 :: String -> Vector SX -> (M.Map String SX, Vector String) -> IO SXFunction sxFunction__2 = casadi__SXFunction__CONSTRUCTOR__2 -- direct wrapper foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__3" c_casadi__SXFunction__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> IO (Ptr SXFunction') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction') casadi__SXFunction__CONSTRUCTOR__3 + :: String -> Vector SX -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction__3 :: String -> Vector SX -> (M.Map String SX, Vector String) -> M.Map String GenericType -> IO SXFunction +sxFunction__3 = casadi__SXFunction__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__4" c_casadi__SXFunction__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SXFunction') +casadi__SXFunction__CONSTRUCTOR__4 + :: String -> (M.Map String SX, Vector String) -> Vector SX -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__CONSTRUCTOR__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction__4 :: String -> (M.Map String SX, Vector String) -> Vector SX -> IO SXFunction +sxFunction__4 = casadi__SXFunction__CONSTRUCTOR__4 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__5" c_casadi__SXFunction__CONSTRUCTOR__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString)))) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction') +casadi__SXFunction__CONSTRUCTOR__5 + :: String -> (M.Map String SX, Vector String) -> Vector SX -> M.Map String GenericType -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__CONSTRUCTOR__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction__5 :: String -> (M.Map String SX, Vector String) -> Vector SX -> M.Map String GenericType -> IO SXFunction +sxFunction__5 = casadi__SXFunction__CONSTRUCTOR__5 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__6" c_casadi__SXFunction__CONSTRUCTOR__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SXFunction') +casadi__SXFunction__CONSTRUCTOR__6 + :: String -> Vector SX -> Vector SX -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__CONSTRUCTOR__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction__6 :: String -> Vector SX -> Vector SX -> IO SXFunction +sxFunction__6 = casadi__SXFunction__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__7" c_casadi__SXFunction__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SXFunction') +casadi__SXFunction__CONSTRUCTOR__7 + :: String -> Vector SX -> Vector SX -> M.Map String GenericType -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__CONSTRUCTOR__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction__7 :: String -> Vector SX -> Vector SX -> M.Map String GenericType -> IO SXFunction +sxFunction__7 = casadi__SXFunction__CONSTRUCTOR__7 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__8" c_casadi__SXFunction__CONSTRUCTOR__8 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr SXFunction') +casadi__SXFunction__CONSTRUCTOR__8 + :: Function -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__CONSTRUCTOR__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction__8 :: Function -> IO SXFunction +sxFunction__8 = casadi__SXFunction__CONSTRUCTOR__8 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__9" c_casadi__SXFunction__CONSTRUCTOR__9 + :: Ptr (Ptr StdString) -> Ptr MXFunction' -> IO (Ptr SXFunction') +casadi__SXFunction__CONSTRUCTOR__9 + :: MXFunction -> IO SXFunction +casadi__SXFunction__CONSTRUCTOR__9 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__CONSTRUCTOR__9 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction__9 :: MXFunction -> IO SXFunction +sxFunction__9 = casadi__SXFunction__CONSTRUCTOR__9 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__CONSTRUCTOR__10" c_casadi__SXFunction__CONSTRUCTOR__10 + :: Ptr (Ptr StdString) -> IO (Ptr SXFunction') +casadi__SXFunction__CONSTRUCTOR__10 :: IO SXFunction -casadi__SXFunction__CONSTRUCTOR__3 = +casadi__SXFunction__CONSTRUCTOR__10 = do errStrPtrP <- new nullPtr - ret <- c_casadi__SXFunction__CONSTRUCTOR__3 errStrPtrP + ret <- c_casadi__SXFunction__CONSTRUCTOR__10 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -sxFunction__3 :: IO SXFunction -sxFunction__3 = casadi__SXFunction__CONSTRUCTOR__3 +sxFunction__10 :: IO SXFunction +sxFunction__10 = casadi__SXFunction__CONSTRUCTOR__10 -- direct wrapper @@ -222,6 +389,27 @@ -- classy wrapper sxFunction_getAlgorithmSize :: SXFunctionClass a => a -> IO Int sxFunction_getAlgorithmSize x = casadi__SXFunction__getAlgorithmSize (castSXFunction x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__SXFunction__getAtomicInput" c_casadi__SXFunction__getAtomicInput + :: Ptr (Ptr StdString) -> Ptr SXFunction' -> CInt -> IO (Ptr (StdPair CInt CInt)) +casadi__SXFunction__getAtomicInput + :: SXFunction -> Int -> IO (Int, Int) +casadi__SXFunction__getAtomicInput x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SXFunction__getAtomicInput errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sxFunction_getAtomicInput :: SXFunctionClass a => a -> Int -> IO (Int, Int) +sxFunction_getAtomicInput x = casadi__SXFunction__getAtomicInput (castSXFunction x) -- direct wrapper diff --git a/Casadi/Core/Classes/SdpSolver.hs b/Casadi/Core/Classes/SdpSolver.hs --- a/Casadi/Core/Classes/SdpSolver.hs +++ b/Casadi/Core/Classes/SdpSolver.hs @@ -9,17 +9,19 @@ ( SdpSolver, SdpSolverClass(..), - sdpSolver, + sdpSolver__0, + sdpSolver__1, + sdpSolver__2, sdpSolver_doc, sdpSolver_hasPlugin, sdpSolver_loadPlugin, - sdpSolver_setSOCPOptions, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -27,31 +29,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR" c_casadi__SdpSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR__0" c_casadi__SdpSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr SdpSolver') +casadi__SdpSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO SdpSolver +casadi__SdpSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SdpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sdpSolver__0 :: String -> String -> M.Map String Sparsity -> IO SdpSolver +sdpSolver__0 = casadi__SdpSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR__1" c_casadi__SdpSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SdpSolver') +casadi__SdpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdpSolver +casadi__SdpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SdpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sdpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdpSolver +sdpSolver__1 = casadi__SdpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR__2" c_casadi__SdpSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr SdpSolver') -casadi__SdpSolver__CONSTRUCTOR +casadi__SdpSolver__CONSTRUCTOR__2 :: IO SdpSolver -casadi__SdpSolver__CONSTRUCTOR = +casadi__SdpSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__SdpSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__SdpSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -sdpSolver :: IO SdpSolver -sdpSolver = casadi__SdpSolver__CONSTRUCTOR +sdpSolver__2 :: IO SdpSolver +sdpSolver__2 = casadi__SdpSolver__CONSTRUCTOR__2 -- direct wrapper @@ -112,24 +158,4 @@ -- classy wrapper sdpSolver_loadPlugin :: String -> IO () sdpSolver_loadPlugin = casadi__SdpSolver__loadPlugin - - --- direct wrapper -foreign import ccall unsafe "casadi__SdpSolver__setSOCPOptions" c_casadi__SdpSolver__setSOCPOptions - :: Ptr (Ptr StdString) -> Ptr SdpSolver' -> IO () -casadi__SdpSolver__setSOCPOptions - :: SdpSolver -> IO () -casadi__SdpSolver__setSOCPOptions x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SdpSolver__setSOCPOptions errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sdpSolver_setSOCPOptions :: SdpSolverClass a => a -> IO () -sdpSolver_setSOCPOptions x = casadi__SdpSolver__setSOCPOptions (castSdpSolver x) diff --git a/Casadi/Core/Classes/SdqpSolver.hs b/Casadi/Core/Classes/SdqpSolver.hs --- a/Casadi/Core/Classes/SdqpSolver.hs +++ b/Casadi/Core/Classes/SdqpSolver.hs @@ -9,17 +9,19 @@ ( SdqpSolver, SdqpSolverClass(..), - sdqpSolver, + sdqpSolver__0, + sdqpSolver__1, + sdqpSolver__2, sdqpSolver_doc, sdqpSolver_hasPlugin, sdqpSolver_loadPlugin, - sdqpSolver_setSOCQPOptions, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -27,31 +29,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR" c_casadi__SdqpSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR__0" c_casadi__SdqpSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr SdqpSolver') +casadi__SdqpSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO SdqpSolver +casadi__SdqpSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SdqpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sdqpSolver__0 :: String -> String -> M.Map String Sparsity -> IO SdqpSolver +sdqpSolver__0 = casadi__SdqpSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR__1" c_casadi__SdqpSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SdqpSolver') +casadi__SdqpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdqpSolver +casadi__SdqpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SdqpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sdqpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SdqpSolver +sdqpSolver__1 = casadi__SdqpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR__2" c_casadi__SdqpSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr SdqpSolver') -casadi__SdqpSolver__CONSTRUCTOR +casadi__SdqpSolver__CONSTRUCTOR__2 :: IO SdqpSolver -casadi__SdqpSolver__CONSTRUCTOR = +casadi__SdqpSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__SdqpSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__SdqpSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -sdqpSolver :: IO SdqpSolver -sdqpSolver = casadi__SdqpSolver__CONSTRUCTOR +sdqpSolver__2 :: IO SdqpSolver +sdqpSolver__2 = casadi__SdqpSolver__CONSTRUCTOR__2 -- direct wrapper @@ -112,24 +158,4 @@ -- classy wrapper sdqpSolver_loadPlugin :: String -> IO () sdqpSolver_loadPlugin = casadi__SdqpSolver__loadPlugin - - --- direct wrapper -foreign import ccall unsafe "casadi__SdqpSolver__setSOCQPOptions" c_casadi__SdqpSolver__setSOCQPOptions - :: Ptr (Ptr StdString) -> Ptr SdqpSolver' -> IO () -casadi__SdqpSolver__setSOCQPOptions - :: SdqpSolver -> IO () -casadi__SdqpSolver__setSOCQPOptions x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SdqpSolver__setSOCQPOptions errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sdqpSolver_setSOCQPOptions :: SdqpSolverClass a => a -> IO () -sdqpSolver_setSOCQPOptions x = casadi__SdqpSolver__setSOCQPOptions (castSdqpSolver x) diff --git a/Casadi/Core/Classes/SharedObject.hs b/Casadi/Core/Classes/SharedObject.hs --- a/Casadi/Core/Classes/SharedObject.hs +++ b/Casadi/Core/Classes/SharedObject.hs @@ -9,6 +9,7 @@ ( SharedObject, SharedObjectClass(..), + sharedObject___hash__, sharedObject_assertInit, sharedObject_getDescription, sharedObject_getRepresentation, @@ -25,6 +26,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -32,13 +34,32 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__SharedObject____hash__" c_casadi__SharedObject____hash__ + :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO CSize +casadi__SharedObject____hash__ + :: SharedObject -> IO CSize +casadi__SharedObject____hash__ x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SharedObject____hash__ errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sharedObject___hash__ :: SharedObjectClass a => a -> IO CSize +sharedObject___hash__ x = casadi__SharedObject____hash__ (castSharedObject x) + + -- direct wrapper foreign import ccall unsafe "casadi__SharedObject__assertInit" c_casadi__SharedObject__assertInit :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO () diff --git a/Casadi/Core/Classes/Simulator.hs b/Casadi/Core/Classes/Simulator.hs --- a/Casadi/Core/Classes/Simulator.hs +++ b/Casadi/Core/Classes/Simulator.hs @@ -20,6 +20,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -27,96 +28,101 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__0" c_casadi__Simulator__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> Ptr Integrator' -> Ptr DMatrix' -> IO (Ptr Simulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr DMatrix' -> IO (Ptr Simulator') casadi__Simulator__CONSTRUCTOR__0 - :: Integrator -> DMatrix -> IO Simulator -casadi__Simulator__CONSTRUCTOR__0 x0 x1 = + :: String -> Integrator -> DMatrix -> IO Simulator +casadi__Simulator__CONSTRUCTOR__0 x0 x1 x2 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__Simulator__CONSTRUCTOR__0 errStrPtrP x0' x1' + ret <- c_casadi__Simulator__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -simulator__0 :: Integrator -> DMatrix -> IO Simulator +simulator__0 :: String -> Integrator -> DMatrix -> IO Simulator simulator__0 = casadi__Simulator__CONSTRUCTOR__0 -- direct wrapper foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__1" c_casadi__Simulator__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> Ptr Integrator' -> Ptr (StdVec CDouble) -> IO (Ptr Simulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Simulator') casadi__Simulator__CONSTRUCTOR__1 - :: Integrator -> Vector Double -> IO Simulator -casadi__Simulator__CONSTRUCTOR__1 x0 x1 = + :: String -> Integrator -> DMatrix -> M.Map String GenericType -> IO Simulator +casadi__Simulator__CONSTRUCTOR__1 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__Simulator__CONSTRUCTOR__1 errStrPtrP x0' x1' + ret <- c_casadi__Simulator__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -simulator__1 :: Integrator -> Vector Double -> IO Simulator +simulator__1 :: String -> Integrator -> DMatrix -> M.Map String GenericType -> IO Simulator simulator__1 = casadi__Simulator__CONSTRUCTOR__1 -- direct wrapper foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__2" c_casadi__Simulator__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> Ptr Integrator' -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr Simulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr Function' -> Ptr DMatrix' -> IO (Ptr Simulator') casadi__Simulator__CONSTRUCTOR__2 - :: Integrator -> Function -> DMatrix -> IO Simulator -casadi__Simulator__CONSTRUCTOR__2 x0 x1 x2 = + :: String -> Integrator -> Function -> DMatrix -> IO Simulator +casadi__Simulator__CONSTRUCTOR__2 x0 x1 x2 x3 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__Simulator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' + ret <- c_casadi__Simulator__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' x3' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -simulator__2 :: Integrator -> Function -> DMatrix -> IO Simulator +simulator__2 :: String -> Integrator -> Function -> DMatrix -> IO Simulator simulator__2 = casadi__Simulator__CONSTRUCTOR__2 -- direct wrapper foreign import ccall unsafe "casadi__Simulator__CONSTRUCTOR__3" c_casadi__Simulator__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> Ptr Integrator' -> Ptr Function' -> Ptr (StdVec CDouble) -> IO (Ptr Simulator') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Integrator' -> Ptr Function' -> Ptr DMatrix' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Simulator') casadi__Simulator__CONSTRUCTOR__3 - :: Integrator -> Function -> Vector Double -> IO Simulator -casadi__Simulator__CONSTRUCTOR__3 x0 x1 x2 = + :: String -> Integrator -> Function -> DMatrix -> M.Map String GenericType -> IO Simulator +casadi__Simulator__CONSTRUCTOR__3 x0 x1 x2 x3 x4 = withMarshal x0 $ \x0' -> withMarshal x1 $ \x1' -> withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> do errStrPtrP <- new nullPtr - ret <- c_casadi__Simulator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' + ret <- c_casadi__Simulator__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' x4' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -simulator__3 :: Integrator -> Function -> Vector Double -> IO Simulator +simulator__3 :: String -> Integrator -> Function -> DMatrix -> M.Map String GenericType -> IO Simulator simulator__3 = casadi__Simulator__CONSTRUCTOR__3 diff --git a/Casadi/Core/Classes/Slice.hs b/Casadi/Core/Classes/Slice.hs --- a/Casadi/Core/Classes/Slice.hs +++ b/Casadi/Core/Classes/Slice.hs @@ -16,15 +16,16 @@ slice__4, slice__5, slice__6, + slice__7, slice_getAll__0, slice_getAll__1, slice_getAll__2, slice_getDescription, slice_getRepresentation, - slice_isScalar, slice_isSlice2, slice_isSlice__0, slice_isSlice__1, + slice_isscalar, slice_operator_equals, slice_operator_nequals, slice_toScalar, @@ -34,6 +35,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -41,9 +43,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data @@ -175,22 +176,43 @@ -- direct wrapper foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__6" c_casadi__Slice__CONSTRUCTOR__6 - :: Ptr (Ptr StdString) -> IO (Ptr Slice') + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Slice') casadi__Slice__CONSTRUCTOR__6 + :: Int -> Bool -> IO Slice +casadi__Slice__CONSTRUCTOR__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Slice__CONSTRUCTOR__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +slice__6 :: Int -> Bool -> IO Slice +slice__6 = casadi__Slice__CONSTRUCTOR__6 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__7" c_casadi__Slice__CONSTRUCTOR__7 + :: Ptr (Ptr StdString) -> IO (Ptr Slice') +casadi__Slice__CONSTRUCTOR__7 :: IO Slice -casadi__Slice__CONSTRUCTOR__6 = +casadi__Slice__CONSTRUCTOR__7 = do errStrPtrP <- new nullPtr - ret <- c_casadi__Slice__CONSTRUCTOR__6 errStrPtrP + ret <- c_casadi__Slice__CONSTRUCTOR__7 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -slice__6 :: IO Slice -slice__6 = casadi__Slice__CONSTRUCTOR__6 +slice__7 :: IO Slice +slice__7 = casadi__Slice__CONSTRUCTOR__7 -- direct wrapper @@ -259,27 +281,6 @@ -- direct wrapper -foreign import ccall unsafe "casadi__Slice__isScalar" c_casadi__Slice__isScalar - :: Ptr (Ptr StdString) -> Ptr Slice' -> CInt -> IO CInt -casadi__Slice__isScalar - :: Slice -> Int -> IO Bool -casadi__Slice__isScalar x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Slice__isScalar errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -slice_isScalar :: SliceClass a => a -> Int -> IO Bool -slice_isScalar x = casadi__Slice__isScalar (castSlice x) - - --- direct wrapper foreign import ccall unsafe "casadi__Slice__isSlice__0" c_casadi__Slice__isSlice__0 :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt casadi__Slice__isSlice__0 @@ -338,6 +339,27 @@ -- classy wrapper slice_isSlice2 :: Vector Int -> IO Bool slice_isSlice2 = casadi__Slice__isSlice2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Slice__isscalar" c_casadi__Slice__isscalar + :: Ptr (Ptr StdString) -> Ptr Slice' -> CInt -> IO CInt +casadi__Slice__isscalar + :: Slice -> Int -> IO Bool +casadi__Slice__isscalar x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Slice__isscalar errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +slice_isscalar :: SliceClass a => a -> Int -> IO Bool +slice_isscalar x = casadi__Slice__isscalar (castSlice x) -- direct wrapper diff --git a/Casadi/Core/Classes/SocpSolver.hs b/Casadi/Core/Classes/SocpSolver.hs --- a/Casadi/Core/Classes/SocpSolver.hs +++ b/Casadi/Core/Classes/SocpSolver.hs @@ -9,7 +9,9 @@ ( SocpSolver, SocpSolverClass(..), - socpSolver, + socpSolver__0, + socpSolver__1, + socpSolver__2, socpSolver_doc, socpSolver_hasPlugin, socpSolver_loadPlugin, @@ -19,6 +21,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -26,31 +29,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR" c_casadi__SocpSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR__0" c_casadi__SocpSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr SocpSolver') +casadi__SocpSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO SocpSolver +casadi__SocpSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SocpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +socpSolver__0 :: String -> String -> M.Map String Sparsity -> IO SocpSolver +socpSolver__0 = casadi__SocpSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR__1" c_casadi__SocpSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SocpSolver') +casadi__SocpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SocpSolver +casadi__SocpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__SocpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +socpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO SocpSolver +socpSolver__1 = casadi__SocpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR__2" c_casadi__SocpSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr SocpSolver') -casadi__SocpSolver__CONSTRUCTOR +casadi__SocpSolver__CONSTRUCTOR__2 :: IO SocpSolver -casadi__SocpSolver__CONSTRUCTOR = +casadi__SocpSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__SocpSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__SocpSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -socpSolver :: IO SocpSolver -socpSolver = casadi__SocpSolver__CONSTRUCTOR +socpSolver__2 :: IO SocpSolver +socpSolver__2 = casadi__SocpSolver__CONSTRUCTOR__2 -- direct wrapper diff --git a/Casadi/Core/Classes/Sparsity.hs b/Casadi/Core/Classes/Sparsity.hs --- a/Casadi/Core/Classes/Sparsity.hs +++ b/Casadi/Core/Classes/Sparsity.hs @@ -27,3530 +27,3084 @@ sparsity_compressed, sparsity_dense__0, sparsity_dense__1, - sparsity_depthFirstSearch, - sparsity_diag__0, - sparsity_diag__1, - sparsity_dimString, - sparsity_dulmageMendelsohn__0, - sparsity_dulmageMendelsohn__1, - sparsity_eliminationTree__0, - sparsity_eliminationTree__1, - sparsity_enlargeColumns__0, - sparsity_enlargeColumns__1, - sparsity_enlargeRows__0, - sparsity_enlargeRows__1, - sparsity_enlarge__0, - sparsity_enlarge__1, - sparsity_erase__0, - sparsity_erase__1, - sparsity_erase__2, - sparsity_erase__3, - sparsity_find__0, - sparsity_find__1, - sparsity_getCCS, - sparsity_getCRS, - sparsity_getCol, - sparsity_getColind, - sparsity_getDiag, - sparsity_getLowerNZ, - sparsity_getNZ__0, - sparsity_getNZ__1, - sparsity_getNZ__2, - sparsity_getRow, - sparsity_getTriplet, - sparsity_getUpperNZ, - sparsity_hasNZ, - sparsity_hash, - sparsity_isDense, - sparsity_isDiagonal, - sparsity_isEmpty__0, - sparsity_isEmpty__1, - sparsity_isEqual__0, - sparsity_isEqual__1, - sparsity_isReshape, - sparsity_isScalar__0, - sparsity_isScalar__1, - sparsity_isSingular, - sparsity_isSquare, - sparsity_isSymmetric, - sparsity_isTranspose, - sparsity_isTril, - sparsity_isTriu, - sparsity_isVector__0, - sparsity_isVector__1, - sparsity_largestFirstOrdering, - sparsity_lower, - sparsity_makeDense, - sparsity_nnz, - sparsity_numel, - sparsity_operator_equals, - sparsity_operator_mul, - sparsity_operator_nequals, - sparsity_operator_plus, - sparsity_patternCombine__0, - sparsity_patternCombine__1, - sparsity_patternIntersection__0, - sparsity_patternIntersection__1, - sparsity_patternInverse, - sparsity_patternProduct, - sparsity_patternUnion__0, - sparsity_patternUnion__1, - sparsity_pmult__0, - sparsity_pmult__1, - sparsity_pmult__2, - sparsity_pmult__3, - sparsity_printCompact, - sparsity_reCache, - sparsity_removeDuplicates, - sparsity_reserve, - sparsity_resize, - sparsity_row, - sparsity_rowcol, - sparsity_rowsSequential__0, - sparsity_rowsSequential__1, - sparsity_sanityCheck__0, - sparsity_sanityCheck__1, - sparsity_scalar__0, - sparsity_scalar__1, - sparsity_size, - sparsity_size1, - sparsity_size2, - sparsity_sizeD, - sparsity_sizeL, - sparsity_sizeU, - sparsity_sparse__0, - sparsity_sparse__1, - sparsity_spy, - sparsity_spyMatlab, - sparsity_starColoring2__0, - sparsity_starColoring2__1, - sparsity_starColoring2__2, - sparsity_starColoring__0, - sparsity_starColoring__1, - sparsity_starColoring__2, - sparsity_stronglyConnectedComponents, - sparsity_sub__0, - sparsity_sub__1, - sparsity_sub__2, - sparsity_sub__3, - sparsity_transpose__0, - sparsity_transpose__1, - sparsity_triplet__0, - sparsity_triplet__1, - sparsity_triplet__2, - sparsity_unidirectionalColoring__0, - sparsity_unidirectionalColoring__1, - sparsity_unidirectionalColoring__2, - sparsity_unit, - sparsity_upper, - sparsity_zz_blockcat, - sparsity_zz_blocksplit, - sparsity_zz_diagcat, - sparsity_zz_diagsplit, - sparsity_zz_horzcat, - sparsity_zz_horzsplit, - sparsity_zz_kron, - sparsity_zz_mtimes__0, - sparsity_zz_mtimes__1, - sparsity_zz_norm_0_mul, - sparsity_zz_repmat__0, - sparsity_zz_repmat__1, - sparsity_zz_reshape__0, - sparsity_zz_reshape__1, - sparsity_zz_sprank, - sparsity_zz_tril__0, - sparsity_zz_tril__1, - sparsity_zz_triu__0, - sparsity_zz_triu__1, - sparsity_zz_vec, - sparsity_zz_vecNZ, - sparsity_zz_vecNZcat, - sparsity_zz_veccat, - sparsity_zz_vertcat, - sparsity_zz_vertsplit, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__0" c_casadi__Sparsity__CONSTRUCTOR__0 - :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__CONSTRUCTOR__0 - :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity -casadi__Sparsity__CONSTRUCTOR__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity -sparsity__0 = casadi__Sparsity__CONSTRUCTOR__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__1" c_casadi__Sparsity__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__CONSTRUCTOR__1 - :: Int -> Int -> IO Sparsity -casadi__Sparsity__CONSTRUCTOR__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__CONSTRUCTOR__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity__1 :: Int -> Int -> IO Sparsity -sparsity__1 = casadi__Sparsity__CONSTRUCTOR__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__2" c_casadi__Sparsity__CONSTRUCTOR__2 - :: Ptr (Ptr StdString) -> IO (Ptr Sparsity') -casadi__Sparsity__CONSTRUCTOR__2 - :: IO Sparsity -casadi__Sparsity__CONSTRUCTOR__2 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__CONSTRUCTOR__2 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity__2 :: IO Sparsity -sparsity__2 = casadi__Sparsity__CONSTRUCTOR__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__3" c_casadi__Sparsity__CONSTRUCTOR__3 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__CONSTRUCTOR__3 - :: Int -> IO Sparsity -casadi__Sparsity__CONSTRUCTOR__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__CONSTRUCTOR__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity__3 :: Int -> IO Sparsity -sparsity__3 = casadi__Sparsity__CONSTRUCTOR__3 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__T" c_casadi__Sparsity__T - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__T - :: Sparsity -> IO Sparsity -casadi__Sparsity__T x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__T errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_T :: SparsityClass a => a -> IO Sparsity -sparsity_T x = casadi__Sparsity__T (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__addNZ" c_casadi__Sparsity__addNZ - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt -casadi__Sparsity__addNZ - :: Sparsity -> Int -> Int -> IO Int -casadi__Sparsity__addNZ x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__addNZ errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_addNZ :: SparsityClass a => a -> Int -> Int -> IO Int -sparsity_addNZ x = casadi__Sparsity__addNZ (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__append" c_casadi__Sparsity__append - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO () -casadi__Sparsity__append - :: Sparsity -> Sparsity -> IO () -casadi__Sparsity__append x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__append errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_append :: SparsityClass a => a -> Sparsity -> IO () -sparsity_append x = casadi__Sparsity__append (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__appendColumns" c_casadi__Sparsity__appendColumns - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO () -casadi__Sparsity__appendColumns - :: Sparsity -> Sparsity -> IO () -casadi__Sparsity__appendColumns x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__appendColumns errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_appendColumns :: SparsityClass a => a -> Sparsity -> IO () -sparsity_appendColumns x = casadi__Sparsity__appendColumns (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__band" c_casadi__Sparsity__band - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__band - :: Int -> Int -> IO Sparsity -casadi__Sparsity__band x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__band errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_band :: Int -> Int -> IO Sparsity -sparsity_band = casadi__Sparsity__band - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__banded" c_casadi__Sparsity__banded - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__banded - :: Int -> Int -> IO Sparsity -casadi__Sparsity__banded x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__banded errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_banded :: Int -> Int -> IO Sparsity -sparsity_banded = casadi__Sparsity__banded - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__bandwidthL" c_casadi__Sparsity__bandwidthL - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__bandwidthL - :: Sparsity -> IO Int -casadi__Sparsity__bandwidthL x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__bandwidthL errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_bandwidthL :: SparsityClass a => a -> IO Int -sparsity_bandwidthL x = casadi__Sparsity__bandwidthL (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__bandwidthU" c_casadi__Sparsity__bandwidthU - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__bandwidthU - :: Sparsity -> IO Int -casadi__Sparsity__bandwidthU x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__bandwidthU errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_bandwidthU :: SparsityClass a => a -> IO Int -sparsity_bandwidthU x = casadi__Sparsity__bandwidthU (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__clearCache" c_casadi__Sparsity__clearCache - :: Ptr (Ptr StdString) -> IO () -casadi__Sparsity__clearCache - :: IO () -casadi__Sparsity__clearCache = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__clearCache errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_clearCache :: IO () -sparsity_clearCache = casadi__Sparsity__clearCache - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__colind" c_casadi__Sparsity__colind - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt -casadi__Sparsity__colind - :: Sparsity -> Int -> IO Int -casadi__Sparsity__colind x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__colind errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_colind :: SparsityClass a => a -> Int -> IO Int -sparsity_colind x = casadi__Sparsity__colind (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__compress" c_casadi__Sparsity__compress - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__compress - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__compress x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__compress errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_compress :: SparsityClass a => a -> IO (Vector Int) -sparsity_compress x = casadi__Sparsity__compress (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__compressed" c_casadi__Sparsity__compressed - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__compressed - :: Vector Int -> IO Sparsity -casadi__Sparsity__compressed x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__compressed errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_compressed :: Vector Int -> IO Sparsity -sparsity_compressed = casadi__Sparsity__compressed - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__dense__0" c_casadi__Sparsity__dense__0 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__dense__0 - :: Int -> IO Sparsity -casadi__Sparsity__dense__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__dense__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_dense__0 :: Int -> IO Sparsity -sparsity_dense__0 = casadi__Sparsity__dense__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__dense__1" c_casadi__Sparsity__dense__1 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__dense__1 - :: Int -> Int -> IO Sparsity -casadi__Sparsity__dense__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__dense__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_dense__1 :: Int -> Int -> IO Sparsity -sparsity_dense__1 = casadi__Sparsity__dense__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__depthFirstSearch" c_casadi__Sparsity__depthFirstSearch - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt -casadi__Sparsity__depthFirstSearch - :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int -casadi__Sparsity__depthFirstSearch x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__depthFirstSearch errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_depthFirstSearch :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int -sparsity_depthFirstSearch x = casadi__Sparsity__depthFirstSearch (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__diag__0" c_casadi__Sparsity__diag__0 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__diag__0 - :: Int -> Int -> IO Sparsity -casadi__Sparsity__diag__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__diag__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_diag__0 :: Int -> Int -> IO Sparsity -sparsity_diag__0 = casadi__Sparsity__diag__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__diag__1" c_casadi__Sparsity__diag__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__diag__1 - :: Int -> IO Sparsity -casadi__Sparsity__diag__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__diag__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_diag__1 :: Int -> IO Sparsity -sparsity_diag__1 = casadi__Sparsity__diag__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__dimString" c_casadi__Sparsity__dimString - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr StdString) -casadi__Sparsity__dimString - :: Sparsity -> IO String -casadi__Sparsity__dimString x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__dimString errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_dimString :: SparsityClass a => a -> IO String -sparsity_dimString x = casadi__Sparsity__dimString (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__0" c_casadi__Sparsity__dulmageMendelsohn__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt -casadi__Sparsity__dulmageMendelsohn__0 - :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int -casadi__Sparsity__dulmageMendelsohn__0 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__dulmageMendelsohn__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_dulmageMendelsohn__0 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int -sparsity_dulmageMendelsohn__0 x = casadi__Sparsity__dulmageMendelsohn__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__1" c_casadi__Sparsity__dulmageMendelsohn__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO CInt -casadi__Sparsity__dulmageMendelsohn__1 - :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int -casadi__Sparsity__dulmageMendelsohn__1 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__dulmageMendelsohn__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_dulmageMendelsohn__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int -sparsity_dulmageMendelsohn__1 x = casadi__Sparsity__dulmageMendelsohn__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__eliminationTree__0" c_casadi__Sparsity__eliminationTree__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__eliminationTree__0 - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__eliminationTree__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__eliminationTree__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_eliminationTree__0 :: SparsityClass a => a -> IO (Vector Int) -sparsity_eliminationTree__0 x = casadi__Sparsity__eliminationTree__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__eliminationTree__1" c_casadi__Sparsity__eliminationTree__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__eliminationTree__1 - :: Sparsity -> Bool -> IO (Vector Int) -casadi__Sparsity__eliminationTree__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__eliminationTree__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_eliminationTree__1 :: SparsityClass a => a -> Bool -> IO (Vector Int) -sparsity_eliminationTree__1 x = casadi__Sparsity__eliminationTree__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__enlarge__0" c_casadi__Sparsity__enlarge__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__enlarge__0 - :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO () -casadi__Sparsity__enlarge__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_enlarge__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () -sparsity_enlarge__0 x = casadi__Sparsity__enlarge__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__enlarge__1" c_casadi__Sparsity__enlarge__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__Sparsity__enlarge__1 - :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -casadi__Sparsity__enlarge__1 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_enlarge__1 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () -sparsity_enlarge__1 x = casadi__Sparsity__enlarge__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__0" c_casadi__Sparsity__enlargeColumns__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__enlargeColumns__0 - :: Sparsity -> Int -> Vector Int -> IO () -casadi__Sparsity__enlargeColumns__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__enlargeColumns__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_enlargeColumns__0 :: SparsityClass a => a -> Int -> Vector Int -> IO () -sparsity_enlargeColumns__0 x = casadi__Sparsity__enlargeColumns__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__1" c_casadi__Sparsity__enlargeColumns__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__Sparsity__enlargeColumns__1 - :: Sparsity -> Int -> Vector Int -> Bool -> IO () -casadi__Sparsity__enlargeColumns__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__enlargeColumns__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_enlargeColumns__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO () -sparsity_enlargeColumns__1 x = casadi__Sparsity__enlargeColumns__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__enlargeRows__0" c_casadi__Sparsity__enlargeRows__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__enlargeRows__0 - :: Sparsity -> Int -> Vector Int -> IO () -casadi__Sparsity__enlargeRows__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__enlargeRows__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_enlargeRows__0 :: SparsityClass a => a -> Int -> Vector Int -> IO () -sparsity_enlargeRows__0 x = casadi__Sparsity__enlargeRows__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__enlargeRows__1" c_casadi__Sparsity__enlargeRows__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO () -casadi__Sparsity__enlargeRows__1 - :: Sparsity -> Int -> Vector Int -> Bool -> IO () -casadi__Sparsity__enlargeRows__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__enlargeRows__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_enlargeRows__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO () -sparsity_enlargeRows__1 x = casadi__Sparsity__enlargeRows__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__erase__0" c_casadi__Sparsity__erase__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__erase__0 - :: Sparsity -> Vector Int -> IO (Vector Int) -casadi__Sparsity__erase__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__erase__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_erase__0 :: SparsityClass a => a -> Vector Int -> IO (Vector Int) -sparsity_erase__0 x = casadi__Sparsity__erase__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__erase__1" c_casadi__Sparsity__erase__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__erase__1 - :: Sparsity -> Vector Int -> Bool -> IO (Vector Int) -casadi__Sparsity__erase__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__erase__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_erase__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO (Vector Int) -sparsity_erase__1 x = casadi__Sparsity__erase__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__erase__2" c_casadi__Sparsity__erase__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__erase__2 - :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int) -casadi__Sparsity__erase__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__erase__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_erase__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int) -sparsity_erase__2 x = casadi__Sparsity__erase__2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__erase__3" c_casadi__Sparsity__erase__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__erase__3 - :: Sparsity -> Vector Int -> Vector Int -> Bool -> IO (Vector Int) -casadi__Sparsity__erase__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__erase__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_erase__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Bool -> IO (Vector Int) -sparsity_erase__3 x = casadi__Sparsity__erase__3 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__find__0" c_casadi__Sparsity__find__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__find__0 - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__find__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__find__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_find__0 :: SparsityClass a => a -> IO (Vector Int) -sparsity_find__0 x = casadi__Sparsity__find__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__find__1" c_casadi__Sparsity__find__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__find__1 - :: Sparsity -> Bool -> IO (Vector Int) -casadi__Sparsity__find__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__find__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_find__1 :: SparsityClass a => a -> Bool -> IO (Vector Int) -sparsity_find__1 x = casadi__Sparsity__find__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getCCS" c_casadi__Sparsity__getCCS - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__getCCS - :: Sparsity -> Vector Int -> Vector Int -> IO () -casadi__Sparsity__getCCS x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getCCS errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getCCS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO () -sparsity_getCCS x = casadi__Sparsity__getCCS (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getCRS" c_casadi__Sparsity__getCRS - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__getCRS - :: Sparsity -> Vector Int -> Vector Int -> IO () -casadi__Sparsity__getCRS x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getCRS errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getCRS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO () -sparsity_getCRS x = casadi__Sparsity__getCRS (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getCol" c_casadi__Sparsity__getCol - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__getCol - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__getCol x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getCol errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getCol :: SparsityClass a => a -> IO (Vector Int) -sparsity_getCol x = casadi__Sparsity__getCol (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getColind" c_casadi__Sparsity__getColind - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__getColind - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__getColind x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getColind errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getColind :: SparsityClass a => a -> IO (Vector Int) -sparsity_getColind x = casadi__Sparsity__getColind (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getDiag" c_casadi__Sparsity__getDiag - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__getDiag - :: Sparsity -> Vector Int -> IO Sparsity -casadi__Sparsity__getDiag x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getDiag errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getDiag :: SparsityClass a => a -> Vector Int -> IO Sparsity -sparsity_getDiag x = casadi__Sparsity__getDiag (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getLowerNZ" c_casadi__Sparsity__getLowerNZ - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__getLowerNZ - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__getLowerNZ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getLowerNZ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getLowerNZ :: SparsityClass a => a -> IO (Vector Int) -sparsity_getLowerNZ x = casadi__Sparsity__getLowerNZ (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getNZ__0" c_casadi__Sparsity__getNZ__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__getNZ__0 - :: Sparsity -> Vector Int -> IO () -casadi__Sparsity__getNZ__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getNZ__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getNZ__0 :: SparsityClass a => a -> Vector Int -> IO () -sparsity_getNZ__0 x = casadi__Sparsity__getNZ__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getNZ__1" c_casadi__Sparsity__getNZ__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__getNZ__1 - :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int) -casadi__Sparsity__getNZ__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getNZ__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getNZ__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int) -sparsity_getNZ__1 x = casadi__Sparsity__getNZ__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getNZ__2" c_casadi__Sparsity__getNZ__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt -casadi__Sparsity__getNZ__2 - :: Sparsity -> Int -> Int -> IO Int -casadi__Sparsity__getNZ__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getNZ__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getNZ__2 :: SparsityClass a => a -> Int -> Int -> IO Int -sparsity_getNZ__2 x = casadi__Sparsity__getNZ__2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getRow" c_casadi__Sparsity__getRow - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__getRow - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__getRow x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getRow errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getRow :: SparsityClass a => a -> IO (Vector Int) -sparsity_getRow x = casadi__Sparsity__getRow (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getTriplet" c_casadi__Sparsity__getTriplet - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__getTriplet - :: Sparsity -> Vector Int -> Vector Int -> IO () -casadi__Sparsity__getTriplet x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getTriplet errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getTriplet :: SparsityClass a => a -> Vector Int -> Vector Int -> IO () -sparsity_getTriplet x = casadi__Sparsity__getTriplet (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__getUpperNZ" c_casadi__Sparsity__getUpperNZ - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__getUpperNZ - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__getUpperNZ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__getUpperNZ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_getUpperNZ :: SparsityClass a => a -> IO (Vector Int) -sparsity_getUpperNZ x = casadi__Sparsity__getUpperNZ (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__hasNZ" c_casadi__Sparsity__hasNZ - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt -casadi__Sparsity__hasNZ - :: Sparsity -> Int -> Int -> IO Bool -casadi__Sparsity__hasNZ x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__hasNZ errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_hasNZ :: SparsityClass a => a -> Int -> Int -> IO Bool -sparsity_hasNZ x = casadi__Sparsity__hasNZ (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__hash" c_casadi__Sparsity__hash - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CSize -casadi__Sparsity__hash - :: Sparsity -> IO CSize -casadi__Sparsity__hash x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__hash errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_hash :: SparsityClass a => a -> IO CSize -sparsity_hash x = casadi__Sparsity__hash (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isDense" c_casadi__Sparsity__isDense - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isDense - :: Sparsity -> IO Bool -casadi__Sparsity__isDense x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isDense errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isDense :: SparsityClass a => a -> IO Bool -sparsity_isDense x = casadi__Sparsity__isDense (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isDiagonal" c_casadi__Sparsity__isDiagonal - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isDiagonal - :: Sparsity -> IO Bool -casadi__Sparsity__isDiagonal x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isDiagonal errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isDiagonal :: SparsityClass a => a -> IO Bool -sparsity_isDiagonal x = casadi__Sparsity__isDiagonal (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isEmpty__0" c_casadi__Sparsity__isEmpty__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isEmpty__0 - :: Sparsity -> IO Bool -casadi__Sparsity__isEmpty__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isEmpty__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isEmpty__0 :: SparsityClass a => a -> IO Bool -sparsity_isEmpty__0 x = casadi__Sparsity__isEmpty__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isEmpty__1" c_casadi__Sparsity__isEmpty__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt -casadi__Sparsity__isEmpty__1 - :: Sparsity -> Bool -> IO Bool -casadi__Sparsity__isEmpty__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isEmpty__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isEmpty__1 :: SparsityClass a => a -> Bool -> IO Bool -sparsity_isEmpty__1 x = casadi__Sparsity__isEmpty__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isEqual__0" c_casadi__Sparsity__isEqual__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt -casadi__Sparsity__isEqual__0 - :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO Bool -casadi__Sparsity__isEqual__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isEqual__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isEqual__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO Bool -sparsity_isEqual__0 x = casadi__Sparsity__isEqual__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isEqual__1" c_casadi__Sparsity__isEqual__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isEqual__1 - :: Sparsity -> Sparsity -> IO Bool -casadi__Sparsity__isEqual__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isEqual__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isEqual__1 :: SparsityClass a => a -> Sparsity -> IO Bool -sparsity_isEqual__1 x = casadi__Sparsity__isEqual__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isReshape" c_casadi__Sparsity__isReshape - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isReshape - :: Sparsity -> Sparsity -> IO Bool -casadi__Sparsity__isReshape x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isReshape errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isReshape :: SparsityClass a => a -> Sparsity -> IO Bool -sparsity_isReshape x = casadi__Sparsity__isReshape (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isScalar__0" c_casadi__Sparsity__isScalar__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isScalar__0 - :: Sparsity -> IO Bool -casadi__Sparsity__isScalar__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isScalar__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isScalar__0 :: SparsityClass a => a -> IO Bool -sparsity_isScalar__0 x = casadi__Sparsity__isScalar__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isScalar__1" c_casadi__Sparsity__isScalar__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt -casadi__Sparsity__isScalar__1 - :: Sparsity -> Bool -> IO Bool -casadi__Sparsity__isScalar__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isScalar__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isScalar__1 :: SparsityClass a => a -> Bool -> IO Bool -sparsity_isScalar__1 x = casadi__Sparsity__isScalar__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isSingular" c_casadi__Sparsity__isSingular - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isSingular - :: Sparsity -> IO Bool -casadi__Sparsity__isSingular x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isSingular errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isSingular :: SparsityClass a => a -> IO Bool -sparsity_isSingular x = casadi__Sparsity__isSingular (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isSquare" c_casadi__Sparsity__isSquare - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isSquare - :: Sparsity -> IO Bool -casadi__Sparsity__isSquare x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isSquare errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isSquare :: SparsityClass a => a -> IO Bool -sparsity_isSquare x = casadi__Sparsity__isSquare (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isSymmetric" c_casadi__Sparsity__isSymmetric - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isSymmetric - :: Sparsity -> IO Bool -casadi__Sparsity__isSymmetric x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isSymmetric errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isSymmetric :: SparsityClass a => a -> IO Bool -sparsity_isSymmetric x = casadi__Sparsity__isSymmetric (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isTranspose" c_casadi__Sparsity__isTranspose - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isTranspose - :: Sparsity -> Sparsity -> IO Bool -casadi__Sparsity__isTranspose x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isTranspose errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isTranspose :: SparsityClass a => a -> Sparsity -> IO Bool -sparsity_isTranspose x = casadi__Sparsity__isTranspose (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isTril" c_casadi__Sparsity__isTril - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isTril - :: Sparsity -> IO Bool -casadi__Sparsity__isTril x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isTril errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isTril :: SparsityClass a => a -> IO Bool -sparsity_isTril x = casadi__Sparsity__isTril (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isTriu" c_casadi__Sparsity__isTriu - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isTriu - :: Sparsity -> IO Bool -casadi__Sparsity__isTriu x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isTriu errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isTriu :: SparsityClass a => a -> IO Bool -sparsity_isTriu x = casadi__Sparsity__isTriu (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isVector__0" c_casadi__Sparsity__isVector__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__isVector__0 - :: Sparsity -> IO Bool -casadi__Sparsity__isVector__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isVector__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isVector__0 :: SparsityClass a => a -> IO Bool -sparsity_isVector__0 x = casadi__Sparsity__isVector__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__isVector__1" c_casadi__Sparsity__isVector__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt -casadi__Sparsity__isVector__1 - :: Sparsity -> Bool -> IO Bool -casadi__Sparsity__isVector__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__isVector__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_isVector__1 :: SparsityClass a => a -> Bool -> IO Bool -sparsity_isVector__1 x = casadi__Sparsity__isVector__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__largestFirstOrdering" c_casadi__Sparsity__largestFirstOrdering - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) -casadi__Sparsity__largestFirstOrdering - :: Sparsity -> IO (Vector Int) -casadi__Sparsity__largestFirstOrdering x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__largestFirstOrdering errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_largestFirstOrdering :: SparsityClass a => a -> IO (Vector Int) -sparsity_largestFirstOrdering x = casadi__Sparsity__largestFirstOrdering (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__lower" c_casadi__Sparsity__lower - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__lower - :: Int -> IO Sparsity -casadi__Sparsity__lower x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__lower errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_lower :: Int -> IO Sparsity -sparsity_lower = casadi__Sparsity__lower - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__makeDense" c_casadi__Sparsity__makeDense - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__makeDense - :: Sparsity -> Vector Int -> IO Sparsity -casadi__Sparsity__makeDense x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__makeDense errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_makeDense :: SparsityClass a => a -> Vector Int -> IO Sparsity -sparsity_makeDense x = casadi__Sparsity__makeDense (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__nnz" c_casadi__Sparsity__nnz - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__nnz - :: Sparsity -> IO Int -casadi__Sparsity__nnz x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__nnz errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_nnz :: SparsityClass a => a -> IO Int -sparsity_nnz x = casadi__Sparsity__nnz (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__numel" c_casadi__Sparsity__numel - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__numel - :: Sparsity -> IO Int -casadi__Sparsity__numel x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__numel errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_numel :: SparsityClass a => a -> IO Int -sparsity_numel x = casadi__Sparsity__numel (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__operator_nequals" c_casadi__Sparsity__operator_nequals - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__operator_nequals - :: Sparsity -> Sparsity -> IO Bool -casadi__Sparsity__operator_nequals x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__operator_nequals errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_operator_nequals :: SparsityClass a => a -> Sparsity -> IO Bool -sparsity_operator_nequals x = casadi__Sparsity__operator_nequals (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__operator_mul" c_casadi__Sparsity__operator_mul - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__operator_mul - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__operator_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__operator_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_operator_mul :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_operator_mul x = casadi__Sparsity__operator_mul (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__operator_plus" c_casadi__Sparsity__operator_plus - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__operator_plus - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__operator_plus x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__operator_plus errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_operator_plus :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_operator_plus x = casadi__Sparsity__operator_plus (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__operator_equals" c_casadi__Sparsity__operator_equals - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__operator_equals - :: Sparsity -> Sparsity -> IO Bool -casadi__Sparsity__operator_equals x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__operator_equals errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_operator_equals :: SparsityClass a => a -> Sparsity -> IO Bool -sparsity_operator_equals x = casadi__Sparsity__operator_equals (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternCombine__0" c_casadi__Sparsity__patternCombine__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__patternCombine__0 - :: Sparsity -> Sparsity -> Bool -> Bool -> IO Sparsity -casadi__Sparsity__patternCombine__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternCombine__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternCombine__0 :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> IO Sparsity -sparsity_patternCombine__0 x = casadi__Sparsity__patternCombine__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternCombine__1" c_casadi__Sparsity__patternCombine__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CUChar) -> IO (Ptr Sparsity') -casadi__Sparsity__patternCombine__1 - :: Sparsity -> Sparsity -> Bool -> Bool -> Vector CUChar -> IO Sparsity -casadi__Sparsity__patternCombine__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternCombine__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternCombine__1 :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> Vector CUChar -> IO Sparsity -sparsity_patternCombine__1 x = casadi__Sparsity__patternCombine__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternIntersection__0" c_casadi__Sparsity__patternIntersection__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__patternIntersection__0 - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__patternIntersection__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternIntersection__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternIntersection__0 :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_patternIntersection__0 x = casadi__Sparsity__patternIntersection__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternIntersection__1" c_casadi__Sparsity__patternIntersection__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr (StdVec CUChar) -> IO (Ptr Sparsity') -casadi__Sparsity__patternIntersection__1 - :: Sparsity -> Sparsity -> Vector CUChar -> IO Sparsity -casadi__Sparsity__patternIntersection__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternIntersection__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternIntersection__1 :: SparsityClass a => a -> Sparsity -> Vector CUChar -> IO Sparsity -sparsity_patternIntersection__1 x = casadi__Sparsity__patternIntersection__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternInverse" c_casadi__Sparsity__patternInverse - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__patternInverse - :: Sparsity -> IO Sparsity -casadi__Sparsity__patternInverse x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternInverse errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternInverse :: SparsityClass a => a -> IO Sparsity -sparsity_patternInverse x = casadi__Sparsity__patternInverse (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternProduct" c_casadi__Sparsity__patternProduct - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__patternProduct - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__patternProduct x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternProduct errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternProduct :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_patternProduct x = casadi__Sparsity__patternProduct (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternUnion__0" c_casadi__Sparsity__patternUnion__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__patternUnion__0 - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__patternUnion__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternUnion__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternUnion__0 :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_patternUnion__0 x = casadi__Sparsity__patternUnion__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__patternUnion__1" c_casadi__Sparsity__patternUnion__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr (StdVec CUChar) -> IO (Ptr Sparsity') -casadi__Sparsity__patternUnion__1 - :: Sparsity -> Sparsity -> Vector CUChar -> IO Sparsity -casadi__Sparsity__patternUnion__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__patternUnion__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_patternUnion__1 :: SparsityClass a => a -> Sparsity -> Vector CUChar -> IO Sparsity -sparsity_patternUnion__1 x = casadi__Sparsity__patternUnion__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__pmult__0" c_casadi__Sparsity__pmult__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__pmult__0 - :: Sparsity -> Vector Int -> IO Sparsity -casadi__Sparsity__pmult__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__pmult__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_pmult__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity -sparsity_pmult__0 x = casadi__Sparsity__pmult__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__pmult__1" c_casadi__Sparsity__pmult__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__pmult__1 - :: Sparsity -> Vector Int -> Bool -> IO Sparsity -casadi__Sparsity__pmult__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__pmult__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_pmult__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity -sparsity_pmult__1 x = casadi__Sparsity__pmult__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__pmult__2" c_casadi__Sparsity__pmult__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__pmult__2 - :: Sparsity -> Vector Int -> Bool -> Bool -> IO Sparsity -casadi__Sparsity__pmult__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__pmult__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_pmult__2 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> IO Sparsity -sparsity_pmult__2 x = casadi__Sparsity__pmult__2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__pmult__3" c_casadi__Sparsity__pmult__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__pmult__3 - :: Sparsity -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity -casadi__Sparsity__pmult__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__pmult__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_pmult__3 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity -sparsity_pmult__3 x = casadi__Sparsity__pmult__3 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__printCompact" c_casadi__Sparsity__printCompact - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () -casadi__Sparsity__printCompact - :: Sparsity -> IO () -casadi__Sparsity__printCompact x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__printCompact errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_printCompact :: SparsityClass a => a -> IO () -sparsity_printCompact x = casadi__Sparsity__printCompact (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__reCache" c_casadi__Sparsity__reCache - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () -casadi__Sparsity__reCache - :: Sparsity -> IO () -casadi__Sparsity__reCache x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__reCache errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_reCache :: SparsityClass a => a -> IO () -sparsity_reCache x = casadi__Sparsity__reCache (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__removeDuplicates" c_casadi__Sparsity__removeDuplicates - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO () -casadi__Sparsity__removeDuplicates - :: Sparsity -> Vector Int -> IO () -casadi__Sparsity__removeDuplicates x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__removeDuplicates errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_removeDuplicates :: SparsityClass a => a -> Vector Int -> IO () -sparsity_removeDuplicates x = casadi__Sparsity__removeDuplicates (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__reserve" c_casadi__Sparsity__reserve - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO () -casadi__Sparsity__reserve - :: Sparsity -> Int -> Int -> IO () -casadi__Sparsity__reserve x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__reserve errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_reserve :: SparsityClass a => a -> Int -> Int -> IO () -sparsity_reserve x = casadi__Sparsity__reserve (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__resize" c_casadi__Sparsity__resize - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO () -casadi__Sparsity__resize - :: Sparsity -> Int -> Int -> IO () -casadi__Sparsity__resize x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__resize errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_resize :: SparsityClass a => a -> Int -> Int -> IO () -sparsity_resize x = casadi__Sparsity__resize (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__row" c_casadi__Sparsity__row - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt -casadi__Sparsity__row - :: Sparsity -> Int -> IO Int -casadi__Sparsity__row x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__row errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_row :: SparsityClass a => a -> Int -> IO Int -sparsity_row x = casadi__Sparsity__row (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__rowcol" c_casadi__Sparsity__rowcol - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__rowcol - :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity -casadi__Sparsity__rowcol x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__rowcol errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_rowcol :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity -sparsity_rowcol = casadi__Sparsity__rowcol - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__rowsSequential__0" c_casadi__Sparsity__rowsSequential__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__rowsSequential__0 - :: Sparsity -> IO Bool -casadi__Sparsity__rowsSequential__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__rowsSequential__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_rowsSequential__0 :: SparsityClass a => a -> IO Bool -sparsity_rowsSequential__0 x = casadi__Sparsity__rowsSequential__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__rowsSequential__1" c_casadi__Sparsity__rowsSequential__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt -casadi__Sparsity__rowsSequential__1 - :: Sparsity -> Bool -> IO Bool -casadi__Sparsity__rowsSequential__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__rowsSequential__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_rowsSequential__1 :: SparsityClass a => a -> Bool -> IO Bool -sparsity_rowsSequential__1 x = casadi__Sparsity__rowsSequential__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sanityCheck__0" c_casadi__Sparsity__sanityCheck__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () -casadi__Sparsity__sanityCheck__0 - :: Sparsity -> IO () -casadi__Sparsity__sanityCheck__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sanityCheck__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sanityCheck__0 :: SparsityClass a => a -> IO () -sparsity_sanityCheck__0 x = casadi__Sparsity__sanityCheck__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sanityCheck__1" c_casadi__Sparsity__sanityCheck__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO () -casadi__Sparsity__sanityCheck__1 - :: Sparsity -> Bool -> IO () -casadi__Sparsity__sanityCheck__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sanityCheck__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sanityCheck__1 :: SparsityClass a => a -> Bool -> IO () -sparsity_sanityCheck__1 x = casadi__Sparsity__sanityCheck__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__scalar__0" c_casadi__Sparsity__scalar__0 - :: Ptr (Ptr StdString) -> IO (Ptr Sparsity') -casadi__Sparsity__scalar__0 - :: IO Sparsity -casadi__Sparsity__scalar__0 = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__scalar__0 errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_scalar__0 :: IO Sparsity -sparsity_scalar__0 = casadi__Sparsity__scalar__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__scalar__1" c_casadi__Sparsity__scalar__1 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__scalar__1 - :: Bool -> IO Sparsity -casadi__Sparsity__scalar__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__scalar__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_scalar__1 :: Bool -> IO Sparsity -sparsity_scalar__1 = casadi__Sparsity__scalar__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__size" c_casadi__Sparsity__size - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__size - :: Sparsity -> IO Int -casadi__Sparsity__size x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__size errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_size :: SparsityClass a => a -> IO Int -sparsity_size x = casadi__Sparsity__size (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__size1" c_casadi__Sparsity__size1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__size1 - :: Sparsity -> IO Int -casadi__Sparsity__size1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__size1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_size1 :: SparsityClass a => a -> IO Int -sparsity_size1 x = casadi__Sparsity__size1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__size2" c_casadi__Sparsity__size2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__size2 - :: Sparsity -> IO Int -casadi__Sparsity__size2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__size2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_size2 :: SparsityClass a => a -> IO Int -sparsity_size2 x = casadi__Sparsity__size2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sizeD" c_casadi__Sparsity__sizeD - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__sizeD - :: Sparsity -> IO Int -casadi__Sparsity__sizeD x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sizeD errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sizeD :: SparsityClass a => a -> IO Int -sparsity_sizeD x = casadi__Sparsity__sizeD (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sizeL" c_casadi__Sparsity__sizeL - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__sizeL - :: Sparsity -> IO Int -casadi__Sparsity__sizeL x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sizeL errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sizeL :: SparsityClass a => a -> IO Int -sparsity_sizeL x = casadi__Sparsity__sizeL (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sizeU" c_casadi__Sparsity__sizeU - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__sizeU - :: Sparsity -> IO Int -casadi__Sparsity__sizeU x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sizeU errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sizeU :: SparsityClass a => a -> IO Int -sparsity_sizeU x = casadi__Sparsity__sizeU (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sparse__0" c_casadi__Sparsity__sparse__0 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__sparse__0 - :: Int -> IO Sparsity -casadi__Sparsity__sparse__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sparse__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sparse__0 :: Int -> IO Sparsity -sparsity_sparse__0 = casadi__Sparsity__sparse__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sparse__1" c_casadi__Sparsity__sparse__1 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__sparse__1 - :: Int -> Int -> IO Sparsity -casadi__Sparsity__sparse__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sparse__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sparse__1 :: Int -> Int -> IO Sparsity -sparsity_sparse__1 = casadi__Sparsity__sparse__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__spy" c_casadi__Sparsity__spy - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () -casadi__Sparsity__spy - :: Sparsity -> IO () -casadi__Sparsity__spy x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__spy errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_spy :: SparsityClass a => a -> IO () -sparsity_spy x = casadi__Sparsity__spy (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__spyMatlab" c_casadi__Sparsity__spyMatlab - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr StdString -> IO () -casadi__Sparsity__spyMatlab - :: Sparsity -> String -> IO () -casadi__Sparsity__spyMatlab x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__spyMatlab errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_spyMatlab :: SparsityClass a => a -> String -> IO () -sparsity_spyMatlab x = casadi__Sparsity__spyMatlab (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__starColoring__0" c_casadi__Sparsity__starColoring__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__starColoring__0 - :: Sparsity -> IO Sparsity -casadi__Sparsity__starColoring__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__starColoring__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_starColoring__0 :: SparsityClass a => a -> IO Sparsity -sparsity_starColoring__0 x = casadi__Sparsity__starColoring__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__starColoring__1" c_casadi__Sparsity__starColoring__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__starColoring__1 - :: Sparsity -> Int -> IO Sparsity -casadi__Sparsity__starColoring__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__starColoring__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_starColoring__1 :: SparsityClass a => a -> Int -> IO Sparsity -sparsity_starColoring__1 x = casadi__Sparsity__starColoring__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__starColoring__2" c_casadi__Sparsity__starColoring__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__starColoring__2 - :: Sparsity -> Int -> Int -> IO Sparsity -casadi__Sparsity__starColoring__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__starColoring__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_starColoring__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity -sparsity_starColoring__2 x = casadi__Sparsity__starColoring__2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__starColoring2__0" c_casadi__Sparsity__starColoring2__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__starColoring2__0 - :: Sparsity -> IO Sparsity -casadi__Sparsity__starColoring2__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__starColoring2__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_starColoring2__0 :: SparsityClass a => a -> IO Sparsity -sparsity_starColoring2__0 x = casadi__Sparsity__starColoring2__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__starColoring2__1" c_casadi__Sparsity__starColoring2__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__starColoring2__1 - :: Sparsity -> Int -> IO Sparsity -casadi__Sparsity__starColoring2__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__starColoring2__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_starColoring2__1 :: SparsityClass a => a -> Int -> IO Sparsity -sparsity_starColoring2__1 x = casadi__Sparsity__starColoring2__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__starColoring2__2" c_casadi__Sparsity__starColoring2__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__starColoring2__2 - :: Sparsity -> Int -> Int -> IO Sparsity -casadi__Sparsity__starColoring2__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__starColoring2__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_starColoring2__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity -sparsity_starColoring2__2 x = casadi__Sparsity__starColoring2__2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__stronglyConnectedComponents" c_casadi__Sparsity__stronglyConnectedComponents - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt -casadi__Sparsity__stronglyConnectedComponents - :: Sparsity -> Vector Int -> Vector Int -> IO Int -casadi__Sparsity__stronglyConnectedComponents x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__stronglyConnectedComponents errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_stronglyConnectedComponents :: SparsityClass a => a -> Vector Int -> Vector Int -> IO Int -sparsity_stronglyConnectedComponents x = casadi__Sparsity__stronglyConnectedComponents (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sub__0" c_casadi__Sparsity__sub__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__sub__0 - :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity -casadi__Sparsity__sub__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sub__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sub__0 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity -sparsity_sub__0 x = casadi__Sparsity__sub__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sub__1" c_casadi__Sparsity__sub__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__sub__1 - :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity -casadi__Sparsity__sub__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sub__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sub__1 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity -sparsity_sub__1 x = casadi__Sparsity__sub__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sub__2" c_casadi__Sparsity__sub__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__sub__2 - :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity -casadi__Sparsity__sub__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sub__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sub__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity -sparsity_sub__2 x = casadi__Sparsity__sub__2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__sub__3" c_casadi__Sparsity__sub__3 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__sub__3 - :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity -casadi__Sparsity__sub__3 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__sub__3 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_sub__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity -sparsity_sub__3 x = casadi__Sparsity__sub__3 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__transpose__0" c_casadi__Sparsity__transpose__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__transpose__0 - :: Sparsity -> Vector Int -> IO Sparsity -casadi__Sparsity__transpose__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__transpose__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_transpose__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity -sparsity_transpose__0 x = casadi__Sparsity__transpose__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__transpose__1" c_casadi__Sparsity__transpose__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__transpose__1 - :: Sparsity -> Vector Int -> Bool -> IO Sparsity -casadi__Sparsity__transpose__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__transpose__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_transpose__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity -sparsity_transpose__1 x = casadi__Sparsity__transpose__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__triplet__0" c_casadi__Sparsity__triplet__0 - :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__triplet__0 - :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity -casadi__Sparsity__triplet__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__triplet__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_triplet__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity -sparsity_triplet__0 = casadi__Sparsity__triplet__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__triplet__1" c_casadi__Sparsity__triplet__1 - :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') -casadi__Sparsity__triplet__1 - :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity -casadi__Sparsity__triplet__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__triplet__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_triplet__1 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity -sparsity_triplet__1 = casadi__Sparsity__triplet__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__triplet__2" c_casadi__Sparsity__triplet__2 - :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__triplet__2 - :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity -casadi__Sparsity__triplet__2 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__triplet__2 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_triplet__2 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity -sparsity_triplet__2 = casadi__Sparsity__triplet__2 - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__0" c_casadi__Sparsity__unidirectionalColoring__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__unidirectionalColoring__0 - :: Sparsity -> IO Sparsity -casadi__Sparsity__unidirectionalColoring__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__unidirectionalColoring__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_unidirectionalColoring__0 :: SparsityClass a => a -> IO Sparsity -sparsity_unidirectionalColoring__0 x = casadi__Sparsity__unidirectionalColoring__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__1" c_casadi__Sparsity__unidirectionalColoring__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__unidirectionalColoring__1 - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__unidirectionalColoring__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__unidirectionalColoring__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_unidirectionalColoring__1 :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_unidirectionalColoring__1 x = casadi__Sparsity__unidirectionalColoring__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__2" c_casadi__Sparsity__unidirectionalColoring__2 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__unidirectionalColoring__2 - :: Sparsity -> Sparsity -> Int -> IO Sparsity -casadi__Sparsity__unidirectionalColoring__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__unidirectionalColoring__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_unidirectionalColoring__2 :: SparsityClass a => a -> Sparsity -> Int -> IO Sparsity -sparsity_unidirectionalColoring__2 x = casadi__Sparsity__unidirectionalColoring__2 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__unit" c_casadi__Sparsity__unit - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__unit - :: Int -> Int -> IO Sparsity -casadi__Sparsity__unit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__unit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_unit :: Int -> Int -> IO Sparsity -sparsity_unit = casadi__Sparsity__unit - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__upper" c_casadi__Sparsity__upper - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__upper - :: Int -> IO Sparsity -casadi__Sparsity__upper x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__upper errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_upper :: Int -> IO Sparsity -sparsity_upper = casadi__Sparsity__upper - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_blockcat" c_casadi__Sparsity__zz_blockcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr Sparsity') -casadi__Sparsity__zz_blockcat - :: Vector (Vector Sparsity) -> IO Sparsity -casadi__Sparsity__zz_blockcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_blockcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_blockcat :: Vector (Vector Sparsity) -> IO Sparsity -sparsity_zz_blockcat = casadi__Sparsity__zz_blockcat - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_blocksplit" c_casadi__Sparsity__zz_blocksplit - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -casadi__Sparsity__zz_blocksplit - :: Sparsity -> Vector Int -> Vector Int -> IO (Vector (Vector Sparsity)) -casadi__Sparsity__zz_blocksplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_blocksplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_blocksplit :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector (Vector Sparsity)) -sparsity_zz_blocksplit x = casadi__Sparsity__zz_blocksplit (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_diagcat" c_casadi__Sparsity__zz_diagcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') -casadi__Sparsity__zz_diagcat - :: Vector Sparsity -> IO Sparsity -casadi__Sparsity__zz_diagcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_diagcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_diagcat :: Vector Sparsity -> IO Sparsity -sparsity_zz_diagcat = casadi__Sparsity__zz_diagcat - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_diagsplit" c_casadi__Sparsity__zz_diagsplit - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity'))) -casadi__Sparsity__zz_diagsplit - :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Sparsity) -casadi__Sparsity__zz_diagsplit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_diagsplit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_diagsplit :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Sparsity) -sparsity_zz_diagsplit x = casadi__Sparsity__zz_diagsplit (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_horzcat" c_casadi__Sparsity__zz_horzcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') -casadi__Sparsity__zz_horzcat - :: Vector Sparsity -> IO Sparsity -casadi__Sparsity__zz_horzcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_horzcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_horzcat :: Vector Sparsity -> IO Sparsity -sparsity_zz_horzcat = casadi__Sparsity__zz_horzcat - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_horzsplit" c_casadi__Sparsity__zz_horzsplit - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity'))) -casadi__Sparsity__zz_horzsplit - :: Sparsity -> Vector Int -> IO (Vector Sparsity) -casadi__Sparsity__zz_horzsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_horzsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_horzsplit :: SparsityClass a => a -> Vector Int -> IO (Vector Sparsity) -sparsity_zz_horzsplit x = casadi__Sparsity__zz_horzsplit (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_kron" c_casadi__Sparsity__zz_kron - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_kron - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__zz_kron x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_kron errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_kron :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_zz_kron x = casadi__Sparsity__zz_kron (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_mtimes__0" c_casadi__Sparsity__zz_mtimes__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_mtimes__0 - :: Sparsity -> Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__zz_mtimes__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_mtimes__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_mtimes__0 :: SparsityClass a => a -> Sparsity -> Sparsity -> IO Sparsity -sparsity_zz_mtimes__0 x = casadi__Sparsity__zz_mtimes__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_mtimes__1" c_casadi__Sparsity__zz_mtimes__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_mtimes__1 - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__zz_mtimes__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_mtimes__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_mtimes__1 :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_zz_mtimes__1 x = casadi__Sparsity__zz_mtimes__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_norm_0_mul" c_casadi__Sparsity__zz_norm_0_mul - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__zz_norm_0_mul - :: Sparsity -> Sparsity -> IO Int -casadi__Sparsity__zz_norm_0_mul x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_norm_0_mul errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_norm_0_mul :: SparsityClass a => a -> Sparsity -> IO Int -sparsity_zz_norm_0_mul x = casadi__Sparsity__zz_norm_0_mul (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_repmat__0" c_casadi__Sparsity__zz_repmat__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__zz_repmat__0 - :: Sparsity -> Int -> IO Sparsity -casadi__Sparsity__zz_repmat__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_repmat__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_repmat__0 :: SparsityClass a => a -> Int -> IO Sparsity -sparsity_zz_repmat__0 x = casadi__Sparsity__zz_repmat__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_repmat__1" c_casadi__Sparsity__zz_repmat__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__zz_repmat__1 - :: Sparsity -> Int -> Int -> IO Sparsity -casadi__Sparsity__zz_repmat__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_repmat__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_repmat__1 :: SparsityClass a => a -> Int -> Int -> IO Sparsity -sparsity_zz_repmat__1 x = casadi__Sparsity__zz_repmat__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_reshape__0" c_casadi__Sparsity__zz_reshape__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_reshape__0 - :: Sparsity -> Sparsity -> IO Sparsity -casadi__Sparsity__zz_reshape__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_reshape__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_reshape__0 :: SparsityClass a => a -> Sparsity -> IO Sparsity -sparsity_zz_reshape__0 x = casadi__Sparsity__zz_reshape__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_reshape__1" c_casadi__Sparsity__zz_reshape__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__zz_reshape__1 - :: Sparsity -> Int -> Int -> IO Sparsity -casadi__Sparsity__zz_reshape__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_reshape__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_reshape__1 :: SparsityClass a => a -> Int -> Int -> IO Sparsity -sparsity_zz_reshape__1 x = casadi__Sparsity__zz_reshape__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_sprank" c_casadi__Sparsity__zz_sprank - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt -casadi__Sparsity__zz_sprank - :: Sparsity -> IO Int -casadi__Sparsity__zz_sprank x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_sprank errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_sprank :: SparsityClass a => a -> IO Int -sparsity_zz_sprank x = casadi__Sparsity__zz_sprank (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_tril__0" c_casadi__Sparsity__zz_tril__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_tril__0 - :: Sparsity -> IO Sparsity -casadi__Sparsity__zz_tril__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_tril__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_tril__0 :: SparsityClass a => a -> IO Sparsity -sparsity_zz_tril__0 x = casadi__Sparsity__zz_tril__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_tril__1" c_casadi__Sparsity__zz_tril__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__zz_tril__1 - :: Sparsity -> Bool -> IO Sparsity -casadi__Sparsity__zz_tril__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_tril__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_tril__1 :: SparsityClass a => a -> Bool -> IO Sparsity -sparsity_zz_tril__1 x = casadi__Sparsity__zz_tril__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_triu__0" c_casadi__Sparsity__zz_triu__0 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_triu__0 - :: Sparsity -> IO Sparsity -casadi__Sparsity__zz_triu__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_triu__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_triu__0 :: SparsityClass a => a -> IO Sparsity -sparsity_zz_triu__0 x = casadi__Sparsity__zz_triu__0 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_triu__1" c_casadi__Sparsity__zz_triu__1 - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') -casadi__Sparsity__zz_triu__1 - :: Sparsity -> Bool -> IO Sparsity -casadi__Sparsity__zz_triu__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_triu__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_triu__1 :: SparsityClass a => a -> Bool -> IO Sparsity -sparsity_zz_triu__1 x = casadi__Sparsity__zz_triu__1 (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_vec" c_casadi__Sparsity__zz_vec - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_vec - :: Sparsity -> IO Sparsity -casadi__Sparsity__zz_vec x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_vec errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_vec :: SparsityClass a => a -> IO Sparsity -sparsity_zz_vec x = casadi__Sparsity__zz_vec (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_vecNZ" c_casadi__Sparsity__zz_vecNZ - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') -casadi__Sparsity__zz_vecNZ - :: Sparsity -> IO Sparsity -casadi__Sparsity__zz_vecNZ x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_vecNZ errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_vecNZ :: SparsityClass a => a -> IO Sparsity -sparsity_zz_vecNZ x = casadi__Sparsity__zz_vecNZ (castSparsity x) - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_vecNZcat" c_casadi__Sparsity__zz_vecNZcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') -casadi__Sparsity__zz_vecNZcat - :: Vector Sparsity -> IO Sparsity -casadi__Sparsity__zz_vecNZcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_vecNZcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_vecNZcat :: Vector Sparsity -> IO Sparsity -sparsity_zz_vecNZcat = casadi__Sparsity__zz_vecNZcat - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_veccat" c_casadi__Sparsity__zz_veccat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') -casadi__Sparsity__zz_veccat - :: Vector Sparsity -> IO Sparsity -casadi__Sparsity__zz_veccat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_veccat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_veccat :: Vector Sparsity -> IO Sparsity -sparsity_zz_veccat = casadi__Sparsity__zz_veccat - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_vertcat" c_casadi__Sparsity__zz_vertcat - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') -casadi__Sparsity__zz_vertcat - :: Vector Sparsity -> IO Sparsity -casadi__Sparsity__zz_vertcat x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_vertcat errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_vertcat :: Vector Sparsity -> IO Sparsity -sparsity_zz_vertcat = casadi__Sparsity__zz_vertcat - - --- direct wrapper -foreign import ccall unsafe "casadi__Sparsity__zz_vertsplit" c_casadi__Sparsity__zz_vertsplit - :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity'))) -casadi__Sparsity__zz_vertsplit - :: Sparsity -> Vector Int -> IO (Vector Sparsity) -casadi__Sparsity__zz_vertsplit x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__Sparsity__zz_vertsplit errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -sparsity_zz_vertsplit :: SparsityClass a => a -> Vector Int -> IO (Vector Sparsity) -sparsity_zz_vertsplit x = casadi__Sparsity__zz_vertsplit (castSparsity x) + sparsity_dense__2, + sparsity_depthFirstSearch, + sparsity_diag__0, + sparsity_diag__1, + sparsity_diag__2, + sparsity_dimString, + sparsity_dulmageMendelsohn__0, + sparsity_dulmageMendelsohn__1, + sparsity_eliminationTree__0, + sparsity_eliminationTree__1, + sparsity_enlargeColumns__0, + sparsity_enlargeColumns__1, + sparsity_enlargeRows__0, + sparsity_enlargeRows__1, + sparsity_enlarge__0, + sparsity_enlarge__1, + sparsity_erase__0, + sparsity_erase__1, + sparsity_erase__2, + sparsity_erase__3, + sparsity_find__0, + sparsity_find__1, + sparsity_getCCS, + sparsity_getCRS, + sparsity_getCol, + sparsity_getColind, + sparsity_getDiag, + sparsity_getLowerNZ, + sparsity_getNZ__0, + sparsity_getNZ__1, + sparsity_getNZ__2, + sparsity_getRow, + sparsity_getTriplet, + sparsity_getUpperNZ, + sparsity_hasNZ, + sparsity_hash, + sparsity_isEqual__0, + sparsity_isEqual__1, + sparsity_isReshape, + sparsity_isTranspose, + sparsity_iscolumn, + sparsity_isdense, + sparsity_isdiag, + sparsity_isempty__0, + sparsity_isempty__1, + sparsity_isrow, + sparsity_isscalar__0, + sparsity_isscalar__1, + sparsity_issingular, + sparsity_issquare, + sparsity_issymmetric, + sparsity_istril, + sparsity_istriu, + sparsity_isvector, + sparsity_largestFirstOrdering, + sparsity_lower, + sparsity_makeDense, + sparsity_nnz, + sparsity_numel, + sparsity_operator_equals, + sparsity_operator_mul, + sparsity_operator_nequals, + sparsity_operator_plus, + sparsity_patternCombine, + sparsity_patternIntersection, + sparsity_patternInverse, + sparsity_patternProduct, + sparsity_patternUnion, + sparsity_pmult__0, + sparsity_pmult__1, + sparsity_pmult__2, + sparsity_pmult__3, + sparsity_printCompact, + sparsity_reCache, + sparsity_removeDuplicates, + sparsity_reserve, + sparsity_resize, + sparsity_row, + sparsity_rowcol, + sparsity_rowsSequential__0, + sparsity_rowsSequential__1, + sparsity_sanityCheck__0, + sparsity_sanityCheck__1, + sparsity_scalar__0, + sparsity_scalar__1, + sparsity_shape, + sparsity_size1, + sparsity_size2, + sparsity_sizeD, + sparsity_sizeL, + sparsity_sizeU, + sparsity_sparse__0, + sparsity_sparse__1, + sparsity_sparse__2, + sparsity_spy, + sparsity_spyMatlab, + sparsity_starColoring2__0, + sparsity_starColoring2__1, + sparsity_starColoring2__2, + sparsity_starColoring__0, + sparsity_starColoring__1, + sparsity_starColoring__2, + sparsity_stronglyConnectedComponents, + sparsity_sub__0, + sparsity_sub__1, + sparsity_sub__2, + sparsity_sub__3, + sparsity_transpose__0, + sparsity_transpose__1, + sparsity_triplet__0, + sparsity_triplet__1, + sparsity_triplet__2, + sparsity_unidirectionalColoring__0, + sparsity_unidirectionalColoring__1, + sparsity_unidirectionalColoring__2, + sparsity_unit, + sparsity_upper, + sparsity_zz_tril__0, + sparsity_zz_tril__1, + sparsity_zz_triu__0, + sparsity_zz_triu__1, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__0" c_casadi__Sparsity__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__CONSTRUCTOR__0 + :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity +casadi__Sparsity__CONSTRUCTOR__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity +sparsity__0 = casadi__Sparsity__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__1" c_casadi__Sparsity__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__CONSTRUCTOR__1 + :: Int -> Int -> IO Sparsity +casadi__Sparsity__CONSTRUCTOR__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__CONSTRUCTOR__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity__1 :: Int -> Int -> IO Sparsity +sparsity__1 = casadi__Sparsity__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__2" c_casadi__Sparsity__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> IO (Ptr Sparsity') +casadi__Sparsity__CONSTRUCTOR__2 + :: IO Sparsity +casadi__Sparsity__CONSTRUCTOR__2 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__CONSTRUCTOR__2 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity__2 :: IO Sparsity +sparsity__2 = casadi__Sparsity__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__CONSTRUCTOR__3" c_casadi__Sparsity__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__CONSTRUCTOR__3 + :: Int -> IO Sparsity +casadi__Sparsity__CONSTRUCTOR__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__CONSTRUCTOR__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity__3 :: Int -> IO Sparsity +sparsity__3 = casadi__Sparsity__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__T" c_casadi__Sparsity__T + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__T + :: Sparsity -> IO Sparsity +casadi__Sparsity__T x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__T errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_T :: SparsityClass a => a -> IO Sparsity +sparsity_T x = casadi__Sparsity__T (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__addNZ" c_casadi__Sparsity__addNZ + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt +casadi__Sparsity__addNZ + :: Sparsity -> Int -> Int -> IO Int +casadi__Sparsity__addNZ x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__addNZ errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_addNZ :: SparsityClass a => a -> Int -> Int -> IO Int +sparsity_addNZ x = casadi__Sparsity__addNZ (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__append" c_casadi__Sparsity__append + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO () +casadi__Sparsity__append + :: Sparsity -> Sparsity -> IO () +casadi__Sparsity__append x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__append errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_append :: SparsityClass a => a -> Sparsity -> IO () +sparsity_append x = casadi__Sparsity__append (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__appendColumns" c_casadi__Sparsity__appendColumns + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO () +casadi__Sparsity__appendColumns + :: Sparsity -> Sparsity -> IO () +casadi__Sparsity__appendColumns x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__appendColumns errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_appendColumns :: SparsityClass a => a -> Sparsity -> IO () +sparsity_appendColumns x = casadi__Sparsity__appendColumns (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__band" c_casadi__Sparsity__band + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__band + :: Int -> Int -> IO Sparsity +casadi__Sparsity__band x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__band errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_band :: Int -> Int -> IO Sparsity +sparsity_band = casadi__Sparsity__band + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__banded" c_casadi__Sparsity__banded + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__banded + :: Int -> Int -> IO Sparsity +casadi__Sparsity__banded x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__banded errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_banded :: Int -> Int -> IO Sparsity +sparsity_banded = casadi__Sparsity__banded + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__bandwidthL" c_casadi__Sparsity__bandwidthL + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__bandwidthL + :: Sparsity -> IO Int +casadi__Sparsity__bandwidthL x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__bandwidthL errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_bandwidthL :: SparsityClass a => a -> IO Int +sparsity_bandwidthL x = casadi__Sparsity__bandwidthL (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__bandwidthU" c_casadi__Sparsity__bandwidthU + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__bandwidthU + :: Sparsity -> IO Int +casadi__Sparsity__bandwidthU x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__bandwidthU errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_bandwidthU :: SparsityClass a => a -> IO Int +sparsity_bandwidthU x = casadi__Sparsity__bandwidthU (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__clearCache" c_casadi__Sparsity__clearCache + :: Ptr (Ptr StdString) -> IO () +casadi__Sparsity__clearCache + :: IO () +casadi__Sparsity__clearCache = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__clearCache errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_clearCache :: IO () +sparsity_clearCache = casadi__Sparsity__clearCache + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__colind" c_casadi__Sparsity__colind + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt +casadi__Sparsity__colind + :: Sparsity -> Int -> IO Int +casadi__Sparsity__colind x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__colind errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_colind :: SparsityClass a => a -> Int -> IO Int +sparsity_colind x = casadi__Sparsity__colind (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__compress" c_casadi__Sparsity__compress + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__compress + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__compress x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__compress errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_compress :: SparsityClass a => a -> IO (Vector Int) +sparsity_compress x = casadi__Sparsity__compress (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__compressed" c_casadi__Sparsity__compressed + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__compressed + :: Vector Int -> IO Sparsity +casadi__Sparsity__compressed x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__compressed errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_compressed :: Vector Int -> IO Sparsity +sparsity_compressed = casadi__Sparsity__compressed + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__dense__0" c_casadi__Sparsity__dense__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__dense__0 + :: (Int, Int) -> IO Sparsity +casadi__Sparsity__dense__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__dense__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_dense__0 :: (Int, Int) -> IO Sparsity +sparsity_dense__0 = casadi__Sparsity__dense__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__dense__1" c_casadi__Sparsity__dense__1 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__dense__1 + :: Int -> IO Sparsity +casadi__Sparsity__dense__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__dense__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_dense__1 :: Int -> IO Sparsity +sparsity_dense__1 = casadi__Sparsity__dense__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__dense__2" c_casadi__Sparsity__dense__2 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__dense__2 + :: Int -> Int -> IO Sparsity +casadi__Sparsity__dense__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__dense__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_dense__2 :: Int -> Int -> IO Sparsity +sparsity_dense__2 = casadi__Sparsity__dense__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__depthFirstSearch" c_casadi__Sparsity__depthFirstSearch + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt +casadi__Sparsity__depthFirstSearch + :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int +casadi__Sparsity__depthFirstSearch x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__depthFirstSearch errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_depthFirstSearch :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Vector Bool -> IO Int +sparsity_depthFirstSearch x = casadi__Sparsity__depthFirstSearch (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__diag__0" c_casadi__Sparsity__diag__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__diag__0 + :: (Int, Int) -> IO Sparsity +casadi__Sparsity__diag__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__diag__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_diag__0 :: (Int, Int) -> IO Sparsity +sparsity_diag__0 = casadi__Sparsity__diag__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__diag__1" c_casadi__Sparsity__diag__1 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__diag__1 + :: Int -> Int -> IO Sparsity +casadi__Sparsity__diag__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__diag__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_diag__1 :: Int -> Int -> IO Sparsity +sparsity_diag__1 = casadi__Sparsity__diag__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__diag__2" c_casadi__Sparsity__diag__2 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__diag__2 + :: Int -> IO Sparsity +casadi__Sparsity__diag__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__diag__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_diag__2 :: Int -> IO Sparsity +sparsity_diag__2 = casadi__Sparsity__diag__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__dimString" c_casadi__Sparsity__dimString + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr StdString) +casadi__Sparsity__dimString + :: Sparsity -> IO String +casadi__Sparsity__dimString x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__dimString errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_dimString :: SparsityClass a => a -> IO String +sparsity_dimString x = casadi__Sparsity__dimString (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__0" c_casadi__Sparsity__dulmageMendelsohn__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt +casadi__Sparsity__dulmageMendelsohn__0 + :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int +casadi__Sparsity__dulmageMendelsohn__0 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__dulmageMendelsohn__0 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_dulmageMendelsohn__0 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> IO Int +sparsity_dulmageMendelsohn__0 x = casadi__Sparsity__dulmageMendelsohn__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__dulmageMendelsohn__1" c_casadi__Sparsity__dulmageMendelsohn__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO CInt +casadi__Sparsity__dulmageMendelsohn__1 + :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int +casadi__Sparsity__dulmageMendelsohn__1 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__dulmageMendelsohn__1 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_dulmageMendelsohn__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int -> Int -> IO Int +sparsity_dulmageMendelsohn__1 x = casadi__Sparsity__dulmageMendelsohn__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__eliminationTree__0" c_casadi__Sparsity__eliminationTree__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__eliminationTree__0 + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__eliminationTree__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__eliminationTree__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_eliminationTree__0 :: SparsityClass a => a -> IO (Vector Int) +sparsity_eliminationTree__0 x = casadi__Sparsity__eliminationTree__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__eliminationTree__1" c_casadi__Sparsity__eliminationTree__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__eliminationTree__1 + :: Sparsity -> Bool -> IO (Vector Int) +casadi__Sparsity__eliminationTree__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__eliminationTree__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_eliminationTree__1 :: SparsityClass a => a -> Bool -> IO (Vector Int) +sparsity_eliminationTree__1 x = casadi__Sparsity__eliminationTree__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__enlarge__0" c_casadi__Sparsity__enlarge__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__enlarge__0 + :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO () +casadi__Sparsity__enlarge__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__enlarge__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_enlarge__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO () +sparsity_enlarge__0 x = casadi__Sparsity__enlarge__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__enlarge__1" c_casadi__Sparsity__enlarge__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__Sparsity__enlarge__1 + :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +casadi__Sparsity__enlarge__1 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__enlarge__1 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_enlarge__1 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> Bool -> IO () +sparsity_enlarge__1 x = casadi__Sparsity__enlarge__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__0" c_casadi__Sparsity__enlargeColumns__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__enlargeColumns__0 + :: Sparsity -> Int -> Vector Int -> IO () +casadi__Sparsity__enlargeColumns__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__enlargeColumns__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_enlargeColumns__0 :: SparsityClass a => a -> Int -> Vector Int -> IO () +sparsity_enlargeColumns__0 x = casadi__Sparsity__enlargeColumns__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__enlargeColumns__1" c_casadi__Sparsity__enlargeColumns__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__Sparsity__enlargeColumns__1 + :: Sparsity -> Int -> Vector Int -> Bool -> IO () +casadi__Sparsity__enlargeColumns__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__enlargeColumns__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_enlargeColumns__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO () +sparsity_enlargeColumns__1 x = casadi__Sparsity__enlargeColumns__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__enlargeRows__0" c_casadi__Sparsity__enlargeRows__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__enlargeRows__0 + :: Sparsity -> Int -> Vector Int -> IO () +casadi__Sparsity__enlargeRows__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__enlargeRows__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_enlargeRows__0 :: SparsityClass a => a -> Int -> Vector Int -> IO () +sparsity_enlargeRows__0 x = casadi__Sparsity__enlargeRows__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__enlargeRows__1" c_casadi__Sparsity__enlargeRows__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> Ptr (StdVec CInt) -> CInt -> IO () +casadi__Sparsity__enlargeRows__1 + :: Sparsity -> Int -> Vector Int -> Bool -> IO () +casadi__Sparsity__enlargeRows__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__enlargeRows__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_enlargeRows__1 :: SparsityClass a => a -> Int -> Vector Int -> Bool -> IO () +sparsity_enlargeRows__1 x = casadi__Sparsity__enlargeRows__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__erase__0" c_casadi__Sparsity__erase__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__erase__0 + :: Sparsity -> Vector Int -> IO (Vector Int) +casadi__Sparsity__erase__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__erase__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_erase__0 :: SparsityClass a => a -> Vector Int -> IO (Vector Int) +sparsity_erase__0 x = casadi__Sparsity__erase__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__erase__1" c_casadi__Sparsity__erase__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__erase__1 + :: Sparsity -> Vector Int -> Bool -> IO (Vector Int) +casadi__Sparsity__erase__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__erase__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_erase__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO (Vector Int) +sparsity_erase__1 x = casadi__Sparsity__erase__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__erase__2" c_casadi__Sparsity__erase__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__erase__2 + :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int) +casadi__Sparsity__erase__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__erase__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_erase__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int) +sparsity_erase__2 x = casadi__Sparsity__erase__2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__erase__3" c_casadi__Sparsity__erase__3 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__erase__3 + :: Sparsity -> Vector Int -> Vector Int -> Bool -> IO (Vector Int) +casadi__Sparsity__erase__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__erase__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_erase__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Bool -> IO (Vector Int) +sparsity_erase__3 x = casadi__Sparsity__erase__3 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__find__0" c_casadi__Sparsity__find__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__find__0 + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__find__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__find__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_find__0 :: SparsityClass a => a -> IO (Vector Int) +sparsity_find__0 x = casadi__Sparsity__find__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__find__1" c_casadi__Sparsity__find__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__find__1 + :: Sparsity -> Bool -> IO (Vector Int) +casadi__Sparsity__find__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__find__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_find__1 :: SparsityClass a => a -> Bool -> IO (Vector Int) +sparsity_find__1 x = casadi__Sparsity__find__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getCCS" c_casadi__Sparsity__getCCS + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__getCCS + :: Sparsity -> Vector Int -> Vector Int -> IO () +casadi__Sparsity__getCCS x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getCCS errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getCCS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO () +sparsity_getCCS x = casadi__Sparsity__getCCS (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getCRS" c_casadi__Sparsity__getCRS + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__getCRS + :: Sparsity -> Vector Int -> Vector Int -> IO () +casadi__Sparsity__getCRS x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getCRS errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getCRS :: SparsityClass a => a -> Vector Int -> Vector Int -> IO () +sparsity_getCRS x = casadi__Sparsity__getCRS (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getCol" c_casadi__Sparsity__getCol + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__getCol + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__getCol x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getCol errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getCol :: SparsityClass a => a -> IO (Vector Int) +sparsity_getCol x = casadi__Sparsity__getCol (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getColind" c_casadi__Sparsity__getColind + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__getColind + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__getColind x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getColind errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getColind :: SparsityClass a => a -> IO (Vector Int) +sparsity_getColind x = casadi__Sparsity__getColind (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getDiag" c_casadi__Sparsity__getDiag + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__getDiag + :: Sparsity -> Vector Int -> IO Sparsity +casadi__Sparsity__getDiag x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getDiag errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getDiag :: SparsityClass a => a -> Vector Int -> IO Sparsity +sparsity_getDiag x = casadi__Sparsity__getDiag (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getLowerNZ" c_casadi__Sparsity__getLowerNZ + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__getLowerNZ + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__getLowerNZ x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getLowerNZ errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getLowerNZ :: SparsityClass a => a -> IO (Vector Int) +sparsity_getLowerNZ x = casadi__Sparsity__getLowerNZ (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getNZ__0" c_casadi__Sparsity__getNZ__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__getNZ__0 + :: Sparsity -> Vector Int -> IO () +casadi__Sparsity__getNZ__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getNZ__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getNZ__0 :: SparsityClass a => a -> Vector Int -> IO () +sparsity_getNZ__0 x = casadi__Sparsity__getNZ__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getNZ__1" c_casadi__Sparsity__getNZ__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__getNZ__1 + :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Int) +casadi__Sparsity__getNZ__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getNZ__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getNZ__1 :: SparsityClass a => a -> Vector Int -> Vector Int -> IO (Vector Int) +sparsity_getNZ__1 x = casadi__Sparsity__getNZ__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getNZ__2" c_casadi__Sparsity__getNZ__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt +casadi__Sparsity__getNZ__2 + :: Sparsity -> Int -> Int -> IO Int +casadi__Sparsity__getNZ__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getNZ__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getNZ__2 :: SparsityClass a => a -> Int -> Int -> IO Int +sparsity_getNZ__2 x = casadi__Sparsity__getNZ__2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getRow" c_casadi__Sparsity__getRow + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__getRow + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__getRow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getRow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getRow :: SparsityClass a => a -> IO (Vector Int) +sparsity_getRow x = casadi__Sparsity__getRow (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getTriplet" c_casadi__Sparsity__getTriplet + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__getTriplet + :: Sparsity -> Vector Int -> Vector Int -> IO () +casadi__Sparsity__getTriplet x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getTriplet errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getTriplet :: SparsityClass a => a -> Vector Int -> Vector Int -> IO () +sparsity_getTriplet x = casadi__Sparsity__getTriplet (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__getUpperNZ" c_casadi__Sparsity__getUpperNZ + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__getUpperNZ + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__getUpperNZ x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__getUpperNZ errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_getUpperNZ :: SparsityClass a => a -> IO (Vector Int) +sparsity_getUpperNZ x = casadi__Sparsity__getUpperNZ (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__hasNZ" c_casadi__Sparsity__hasNZ + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO CInt +casadi__Sparsity__hasNZ + :: Sparsity -> Int -> Int -> IO Bool +casadi__Sparsity__hasNZ x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__hasNZ errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_hasNZ :: SparsityClass a => a -> Int -> Int -> IO Bool +sparsity_hasNZ x = casadi__Sparsity__hasNZ (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__hash" c_casadi__Sparsity__hash + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CSize +casadi__Sparsity__hash + :: Sparsity -> IO CSize +casadi__Sparsity__hash x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__hash errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_hash :: SparsityClass a => a -> IO CSize +sparsity_hash x = casadi__Sparsity__hash (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isEqual__0" c_casadi__Sparsity__isEqual__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt +casadi__Sparsity__isEqual__0 + :: Sparsity -> Int -> Int -> Vector Int -> Vector Int -> IO Bool +casadi__Sparsity__isEqual__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isEqual__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isEqual__0 :: SparsityClass a => a -> Int -> Int -> Vector Int -> Vector Int -> IO Bool +sparsity_isEqual__0 x = casadi__Sparsity__isEqual__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isEqual__1" c_casadi__Sparsity__isEqual__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isEqual__1 + :: Sparsity -> Sparsity -> IO Bool +casadi__Sparsity__isEqual__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isEqual__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isEqual__1 :: SparsityClass a => a -> Sparsity -> IO Bool +sparsity_isEqual__1 x = casadi__Sparsity__isEqual__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isReshape" c_casadi__Sparsity__isReshape + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isReshape + :: Sparsity -> Sparsity -> IO Bool +casadi__Sparsity__isReshape x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isReshape errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isReshape :: SparsityClass a => a -> Sparsity -> IO Bool +sparsity_isReshape x = casadi__Sparsity__isReshape (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isTranspose" c_casadi__Sparsity__isTranspose + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isTranspose + :: Sparsity -> Sparsity -> IO Bool +casadi__Sparsity__isTranspose x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isTranspose errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isTranspose :: SparsityClass a => a -> Sparsity -> IO Bool +sparsity_isTranspose x = casadi__Sparsity__isTranspose (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__iscolumn" c_casadi__Sparsity__iscolumn + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__iscolumn + :: Sparsity -> IO Bool +casadi__Sparsity__iscolumn x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__iscolumn errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_iscolumn :: SparsityClass a => a -> IO Bool +sparsity_iscolumn x = casadi__Sparsity__iscolumn (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isdense" c_casadi__Sparsity__isdense + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isdense + :: Sparsity -> IO Bool +casadi__Sparsity__isdense x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isdense errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isdense :: SparsityClass a => a -> IO Bool +sparsity_isdense x = casadi__Sparsity__isdense (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isdiag" c_casadi__Sparsity__isdiag + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isdiag + :: Sparsity -> IO Bool +casadi__Sparsity__isdiag x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isdiag errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isdiag :: SparsityClass a => a -> IO Bool +sparsity_isdiag x = casadi__Sparsity__isdiag (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isempty__0" c_casadi__Sparsity__isempty__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isempty__0 + :: Sparsity -> IO Bool +casadi__Sparsity__isempty__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isempty__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isempty__0 :: SparsityClass a => a -> IO Bool +sparsity_isempty__0 x = casadi__Sparsity__isempty__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isempty__1" c_casadi__Sparsity__isempty__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt +casadi__Sparsity__isempty__1 + :: Sparsity -> Bool -> IO Bool +casadi__Sparsity__isempty__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isempty__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isempty__1 :: SparsityClass a => a -> Bool -> IO Bool +sparsity_isempty__1 x = casadi__Sparsity__isempty__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isrow" c_casadi__Sparsity__isrow + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isrow + :: Sparsity -> IO Bool +casadi__Sparsity__isrow x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isrow errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isrow :: SparsityClass a => a -> IO Bool +sparsity_isrow x = casadi__Sparsity__isrow (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isscalar__0" c_casadi__Sparsity__isscalar__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isscalar__0 + :: Sparsity -> IO Bool +casadi__Sparsity__isscalar__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isscalar__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isscalar__0 :: SparsityClass a => a -> IO Bool +sparsity_isscalar__0 x = casadi__Sparsity__isscalar__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isscalar__1" c_casadi__Sparsity__isscalar__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt +casadi__Sparsity__isscalar__1 + :: Sparsity -> Bool -> IO Bool +casadi__Sparsity__isscalar__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isscalar__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isscalar__1 :: SparsityClass a => a -> Bool -> IO Bool +sparsity_isscalar__1 x = casadi__Sparsity__isscalar__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__issingular" c_casadi__Sparsity__issingular + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__issingular + :: Sparsity -> IO Bool +casadi__Sparsity__issingular x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__issingular errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_issingular :: SparsityClass a => a -> IO Bool +sparsity_issingular x = casadi__Sparsity__issingular (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__issquare" c_casadi__Sparsity__issquare + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__issquare + :: Sparsity -> IO Bool +casadi__Sparsity__issquare x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__issquare errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_issquare :: SparsityClass a => a -> IO Bool +sparsity_issquare x = casadi__Sparsity__issquare (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__issymmetric" c_casadi__Sparsity__issymmetric + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__issymmetric + :: Sparsity -> IO Bool +casadi__Sparsity__issymmetric x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__issymmetric errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_issymmetric :: SparsityClass a => a -> IO Bool +sparsity_issymmetric x = casadi__Sparsity__issymmetric (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__istril" c_casadi__Sparsity__istril + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__istril + :: Sparsity -> IO Bool +casadi__Sparsity__istril x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__istril errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_istril :: SparsityClass a => a -> IO Bool +sparsity_istril x = casadi__Sparsity__istril (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__istriu" c_casadi__Sparsity__istriu + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__istriu + :: Sparsity -> IO Bool +casadi__Sparsity__istriu x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__istriu errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_istriu :: SparsityClass a => a -> IO Bool +sparsity_istriu x = casadi__Sparsity__istriu (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__isvector" c_casadi__Sparsity__isvector + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__isvector + :: Sparsity -> IO Bool +casadi__Sparsity__isvector x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__isvector errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_isvector :: SparsityClass a => a -> IO Bool +sparsity_isvector x = casadi__Sparsity__isvector (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__largestFirstOrdering" c_casadi__Sparsity__largestFirstOrdering + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec CInt)) +casadi__Sparsity__largestFirstOrdering + :: Sparsity -> IO (Vector Int) +casadi__Sparsity__largestFirstOrdering x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__largestFirstOrdering errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_largestFirstOrdering :: SparsityClass a => a -> IO (Vector Int) +sparsity_largestFirstOrdering x = casadi__Sparsity__largestFirstOrdering (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__lower" c_casadi__Sparsity__lower + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__lower + :: Int -> IO Sparsity +casadi__Sparsity__lower x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__lower errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_lower :: Int -> IO Sparsity +sparsity_lower = casadi__Sparsity__lower + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__makeDense" c_casadi__Sparsity__makeDense + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__makeDense + :: Sparsity -> Vector Int -> IO Sparsity +casadi__Sparsity__makeDense x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__makeDense errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_makeDense :: SparsityClass a => a -> Vector Int -> IO Sparsity +sparsity_makeDense x = casadi__Sparsity__makeDense (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__nnz" c_casadi__Sparsity__nnz + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__nnz + :: Sparsity -> IO Int +casadi__Sparsity__nnz x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__nnz errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_nnz :: SparsityClass a => a -> IO Int +sparsity_nnz x = casadi__Sparsity__nnz (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__numel" c_casadi__Sparsity__numel + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__numel + :: Sparsity -> IO Int +casadi__Sparsity__numel x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__numel errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_numel :: SparsityClass a => a -> IO Int +sparsity_numel x = casadi__Sparsity__numel (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__operator_nequals" c_casadi__Sparsity__operator_nequals + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__operator_nequals + :: Sparsity -> Sparsity -> IO Bool +casadi__Sparsity__operator_nequals x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__operator_nequals errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_operator_nequals :: SparsityClass a => a -> Sparsity -> IO Bool +sparsity_operator_nequals x = casadi__Sparsity__operator_nequals (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__operator_mul" c_casadi__Sparsity__operator_mul + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__operator_mul + :: Sparsity -> Sparsity -> IO Sparsity +casadi__Sparsity__operator_mul x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__operator_mul errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_operator_mul :: SparsityClass a => a -> Sparsity -> IO Sparsity +sparsity_operator_mul x = casadi__Sparsity__operator_mul (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__operator_plus" c_casadi__Sparsity__operator_plus + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__operator_plus + :: Sparsity -> Sparsity -> IO Sparsity +casadi__Sparsity__operator_plus x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__operator_plus errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_operator_plus :: SparsityClass a => a -> Sparsity -> IO Sparsity +sparsity_operator_plus x = casadi__Sparsity__operator_plus (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__operator_equals" c_casadi__Sparsity__operator_equals + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__operator_equals + :: Sparsity -> Sparsity -> IO Bool +casadi__Sparsity__operator_equals x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__operator_equals errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_operator_equals :: SparsityClass a => a -> Sparsity -> IO Bool +sparsity_operator_equals x = casadi__Sparsity__operator_equals (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__patternCombine" c_casadi__Sparsity__patternCombine + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__patternCombine + :: Sparsity -> Sparsity -> Bool -> Bool -> IO Sparsity +casadi__Sparsity__patternCombine x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__patternCombine errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_patternCombine :: SparsityClass a => a -> Sparsity -> Bool -> Bool -> IO Sparsity +sparsity_patternCombine x = casadi__Sparsity__patternCombine (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__patternIntersection" c_casadi__Sparsity__patternIntersection + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__patternIntersection + :: Sparsity -> Sparsity -> IO Sparsity +casadi__Sparsity__patternIntersection x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__patternIntersection errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_patternIntersection :: SparsityClass a => a -> Sparsity -> IO Sparsity +sparsity_patternIntersection x = casadi__Sparsity__patternIntersection (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__patternInverse" c_casadi__Sparsity__patternInverse + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__patternInverse + :: Sparsity -> IO Sparsity +casadi__Sparsity__patternInverse x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__patternInverse errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_patternInverse :: SparsityClass a => a -> IO Sparsity +sparsity_patternInverse x = casadi__Sparsity__patternInverse (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__patternProduct" c_casadi__Sparsity__patternProduct + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__patternProduct + :: Sparsity -> Sparsity -> IO Sparsity +casadi__Sparsity__patternProduct x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__patternProduct errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_patternProduct :: SparsityClass a => a -> Sparsity -> IO Sparsity +sparsity_patternProduct x = casadi__Sparsity__patternProduct (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__patternUnion" c_casadi__Sparsity__patternUnion + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__patternUnion + :: Sparsity -> Sparsity -> IO Sparsity +casadi__Sparsity__patternUnion x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__patternUnion errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_patternUnion :: SparsityClass a => a -> Sparsity -> IO Sparsity +sparsity_patternUnion x = casadi__Sparsity__patternUnion (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__pmult__0" c_casadi__Sparsity__pmult__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__pmult__0 + :: Sparsity -> Vector Int -> IO Sparsity +casadi__Sparsity__pmult__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__pmult__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_pmult__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity +sparsity_pmult__0 x = casadi__Sparsity__pmult__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__pmult__1" c_casadi__Sparsity__pmult__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__pmult__1 + :: Sparsity -> Vector Int -> Bool -> IO Sparsity +casadi__Sparsity__pmult__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__pmult__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_pmult__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity +sparsity_pmult__1 x = casadi__Sparsity__pmult__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__pmult__2" c_casadi__Sparsity__pmult__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__pmult__2 + :: Sparsity -> Vector Int -> Bool -> Bool -> IO Sparsity +casadi__Sparsity__pmult__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__pmult__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_pmult__2 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> IO Sparsity +sparsity_pmult__2 x = casadi__Sparsity__pmult__2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__pmult__3" c_casadi__Sparsity__pmult__3 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__pmult__3 + :: Sparsity -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity +casadi__Sparsity__pmult__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__pmult__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_pmult__3 :: SparsityClass a => a -> Vector Int -> Bool -> Bool -> Bool -> IO Sparsity +sparsity_pmult__3 x = casadi__Sparsity__pmult__3 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__printCompact" c_casadi__Sparsity__printCompact + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () +casadi__Sparsity__printCompact + :: Sparsity -> IO () +casadi__Sparsity__printCompact x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__printCompact errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_printCompact :: SparsityClass a => a -> IO () +sparsity_printCompact x = casadi__Sparsity__printCompact (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__reCache" c_casadi__Sparsity__reCache + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () +casadi__Sparsity__reCache + :: Sparsity -> IO () +casadi__Sparsity__reCache x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__reCache errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_reCache :: SparsityClass a => a -> IO () +sparsity_reCache x = casadi__Sparsity__reCache (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__removeDuplicates" c_casadi__Sparsity__removeDuplicates + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO () +casadi__Sparsity__removeDuplicates + :: Sparsity -> Vector Int -> IO () +casadi__Sparsity__removeDuplicates x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__removeDuplicates errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_removeDuplicates :: SparsityClass a => a -> Vector Int -> IO () +sparsity_removeDuplicates x = casadi__Sparsity__removeDuplicates (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__reserve" c_casadi__Sparsity__reserve + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO () +casadi__Sparsity__reserve + :: Sparsity -> Int -> Int -> IO () +casadi__Sparsity__reserve x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__reserve errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_reserve :: SparsityClass a => a -> Int -> Int -> IO () +sparsity_reserve x = casadi__Sparsity__reserve (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__resize" c_casadi__Sparsity__resize + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO () +casadi__Sparsity__resize + :: Sparsity -> Int -> Int -> IO () +casadi__Sparsity__resize x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__resize errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_resize :: SparsityClass a => a -> Int -> Int -> IO () +sparsity_resize x = casadi__Sparsity__resize (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__row" c_casadi__Sparsity__row + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt +casadi__Sparsity__row + :: Sparsity -> Int -> IO Int +casadi__Sparsity__row x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__row errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_row :: SparsityClass a => a -> Int -> IO Int +sparsity_row x = casadi__Sparsity__row (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__rowcol" c_casadi__Sparsity__rowcol + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__rowcol + :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity +casadi__Sparsity__rowcol x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__rowcol errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_rowcol :: Vector Int -> Vector Int -> Int -> Int -> IO Sparsity +sparsity_rowcol = casadi__Sparsity__rowcol + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__rowsSequential__0" c_casadi__Sparsity__rowsSequential__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__rowsSequential__0 + :: Sparsity -> IO Bool +casadi__Sparsity__rowsSequential__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__rowsSequential__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_rowsSequential__0 :: SparsityClass a => a -> IO Bool +sparsity_rowsSequential__0 x = casadi__Sparsity__rowsSequential__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__rowsSequential__1" c_casadi__Sparsity__rowsSequential__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO CInt +casadi__Sparsity__rowsSequential__1 + :: Sparsity -> Bool -> IO Bool +casadi__Sparsity__rowsSequential__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__rowsSequential__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_rowsSequential__1 :: SparsityClass a => a -> Bool -> IO Bool +sparsity_rowsSequential__1 x = casadi__Sparsity__rowsSequential__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sanityCheck__0" c_casadi__Sparsity__sanityCheck__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () +casadi__Sparsity__sanityCheck__0 + :: Sparsity -> IO () +casadi__Sparsity__sanityCheck__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sanityCheck__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sanityCheck__0 :: SparsityClass a => a -> IO () +sparsity_sanityCheck__0 x = casadi__Sparsity__sanityCheck__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sanityCheck__1" c_casadi__Sparsity__sanityCheck__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO () +casadi__Sparsity__sanityCheck__1 + :: Sparsity -> Bool -> IO () +casadi__Sparsity__sanityCheck__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sanityCheck__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sanityCheck__1 :: SparsityClass a => a -> Bool -> IO () +sparsity_sanityCheck__1 x = casadi__Sparsity__sanityCheck__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__scalar__0" c_casadi__Sparsity__scalar__0 + :: Ptr (Ptr StdString) -> IO (Ptr Sparsity') +casadi__Sparsity__scalar__0 + :: IO Sparsity +casadi__Sparsity__scalar__0 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__scalar__0 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_scalar__0 :: IO Sparsity +sparsity_scalar__0 = casadi__Sparsity__scalar__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__scalar__1" c_casadi__Sparsity__scalar__1 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__scalar__1 + :: Bool -> IO Sparsity +casadi__Sparsity__scalar__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__scalar__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_scalar__1 :: Bool -> IO Sparsity +sparsity_scalar__1 = casadi__Sparsity__scalar__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__shape" c_casadi__Sparsity__shape + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdPair CInt CInt)) +casadi__Sparsity__shape + :: Sparsity -> IO (Int, Int) +casadi__Sparsity__shape x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__shape errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_shape :: SparsityClass a => a -> IO (Int, Int) +sparsity_shape x = casadi__Sparsity__shape (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__size1" c_casadi__Sparsity__size1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__size1 + :: Sparsity -> IO Int +casadi__Sparsity__size1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__size1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_size1 :: SparsityClass a => a -> IO Int +sparsity_size1 x = casadi__Sparsity__size1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__size2" c_casadi__Sparsity__size2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__size2 + :: Sparsity -> IO Int +casadi__Sparsity__size2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__size2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_size2 :: SparsityClass a => a -> IO Int +sparsity_size2 x = casadi__Sparsity__size2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sizeD" c_casadi__Sparsity__sizeD + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__sizeD + :: Sparsity -> IO Int +casadi__Sparsity__sizeD x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sizeD errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sizeD :: SparsityClass a => a -> IO Int +sparsity_sizeD x = casadi__Sparsity__sizeD (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sizeL" c_casadi__Sparsity__sizeL + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__sizeL + :: Sparsity -> IO Int +casadi__Sparsity__sizeL x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sizeL errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sizeL :: SparsityClass a => a -> IO Int +sparsity_sizeL x = casadi__Sparsity__sizeL (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sizeU" c_casadi__Sparsity__sizeU + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi__Sparsity__sizeU + :: Sparsity -> IO Int +casadi__Sparsity__sizeU x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sizeU errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sizeU :: SparsityClass a => a -> IO Int +sparsity_sizeU x = casadi__Sparsity__sizeU (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sparse__0" c_casadi__Sparsity__sparse__0 + :: Ptr (Ptr StdString) -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__sparse__0 + :: (Int, Int) -> IO Sparsity +casadi__Sparsity__sparse__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sparse__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sparse__0 :: (Int, Int) -> IO Sparsity +sparsity_sparse__0 = casadi__Sparsity__sparse__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sparse__1" c_casadi__Sparsity__sparse__1 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__sparse__1 + :: Int -> IO Sparsity +casadi__Sparsity__sparse__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sparse__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sparse__1 :: Int -> IO Sparsity +sparsity_sparse__1 = casadi__Sparsity__sparse__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sparse__2" c_casadi__Sparsity__sparse__2 + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__sparse__2 + :: Int -> Int -> IO Sparsity +casadi__Sparsity__sparse__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sparse__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sparse__2 :: Int -> Int -> IO Sparsity +sparsity_sparse__2 = casadi__Sparsity__sparse__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__spy" c_casadi__Sparsity__spy + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO () +casadi__Sparsity__spy + :: Sparsity -> IO () +casadi__Sparsity__spy x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__spy errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_spy :: SparsityClass a => a -> IO () +sparsity_spy x = casadi__Sparsity__spy (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__spyMatlab" c_casadi__Sparsity__spyMatlab + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr StdString -> IO () +casadi__Sparsity__spyMatlab + :: Sparsity -> String -> IO () +casadi__Sparsity__spyMatlab x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__spyMatlab errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_spyMatlab :: SparsityClass a => a -> String -> IO () +sparsity_spyMatlab x = casadi__Sparsity__spyMatlab (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__starColoring__0" c_casadi__Sparsity__starColoring__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__starColoring__0 + :: Sparsity -> IO Sparsity +casadi__Sparsity__starColoring__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__starColoring__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_starColoring__0 :: SparsityClass a => a -> IO Sparsity +sparsity_starColoring__0 x = casadi__Sparsity__starColoring__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__starColoring__1" c_casadi__Sparsity__starColoring__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__starColoring__1 + :: Sparsity -> Int -> IO Sparsity +casadi__Sparsity__starColoring__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__starColoring__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_starColoring__1 :: SparsityClass a => a -> Int -> IO Sparsity +sparsity_starColoring__1 x = casadi__Sparsity__starColoring__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__starColoring__2" c_casadi__Sparsity__starColoring__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__starColoring__2 + :: Sparsity -> Int -> Int -> IO Sparsity +casadi__Sparsity__starColoring__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__starColoring__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_starColoring__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity +sparsity_starColoring__2 x = casadi__Sparsity__starColoring__2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__starColoring2__0" c_casadi__Sparsity__starColoring2__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__starColoring2__0 + :: Sparsity -> IO Sparsity +casadi__Sparsity__starColoring2__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__starColoring2__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_starColoring2__0 :: SparsityClass a => a -> IO Sparsity +sparsity_starColoring2__0 x = casadi__Sparsity__starColoring2__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__starColoring2__1" c_casadi__Sparsity__starColoring2__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__starColoring2__1 + :: Sparsity -> Int -> IO Sparsity +casadi__Sparsity__starColoring2__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__starColoring2__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_starColoring2__1 :: SparsityClass a => a -> Int -> IO Sparsity +sparsity_starColoring2__1 x = casadi__Sparsity__starColoring2__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__starColoring2__2" c_casadi__Sparsity__starColoring2__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__starColoring2__2 + :: Sparsity -> Int -> Int -> IO Sparsity +casadi__Sparsity__starColoring2__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__starColoring2__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_starColoring2__2 :: SparsityClass a => a -> Int -> Int -> IO Sparsity +sparsity_starColoring2__2 x = casadi__Sparsity__starColoring2__2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__stronglyConnectedComponents" c_casadi__Sparsity__stronglyConnectedComponents + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt +casadi__Sparsity__stronglyConnectedComponents + :: Sparsity -> Vector Int -> Vector Int -> IO Int +casadi__Sparsity__stronglyConnectedComponents x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__stronglyConnectedComponents errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_stronglyConnectedComponents :: SparsityClass a => a -> Vector Int -> Vector Int -> IO Int +sparsity_stronglyConnectedComponents x = casadi__Sparsity__stronglyConnectedComponents (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sub__0" c_casadi__Sparsity__sub__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__sub__0 + :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity +casadi__Sparsity__sub__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sub__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sub__0 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> IO Sparsity +sparsity_sub__0 x = casadi__Sparsity__sub__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sub__1" c_casadi__Sparsity__sub__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__sub__1 + :: Sparsity -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity +casadi__Sparsity__sub__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sub__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sub__1 :: SparsityClass a => a -> Vector Int -> Sparsity -> Vector Int -> Bool -> IO Sparsity +sparsity_sub__1 x = casadi__Sparsity__sub__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sub__2" c_casadi__Sparsity__sub__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__sub__2 + :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity +casadi__Sparsity__sub__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sub__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sub__2 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity +sparsity_sub__2 x = casadi__Sparsity__sub__2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__sub__3" c_casadi__Sparsity__sub__3 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__sub__3 + :: Sparsity -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity +casadi__Sparsity__sub__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__sub__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_sub__3 :: SparsityClass a => a -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity +sparsity_sub__3 x = casadi__Sparsity__sub__3 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__transpose__0" c_casadi__Sparsity__transpose__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__transpose__0 + :: Sparsity -> Vector Int -> IO Sparsity +casadi__Sparsity__transpose__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__transpose__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_transpose__0 :: SparsityClass a => a -> Vector Int -> IO Sparsity +sparsity_transpose__0 x = casadi__Sparsity__transpose__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__transpose__1" c_casadi__Sparsity__transpose__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__transpose__1 + :: Sparsity -> Vector Int -> Bool -> IO Sparsity +casadi__Sparsity__transpose__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__transpose__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_transpose__1 :: SparsityClass a => a -> Vector Int -> Bool -> IO Sparsity +sparsity_transpose__1 x = casadi__Sparsity__transpose__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__triplet__0" c_casadi__Sparsity__triplet__0 + :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__triplet__0 + :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity +casadi__Sparsity__triplet__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__triplet__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_triplet__0 :: Int -> Int -> Vector Int -> Vector Int -> IO Sparsity +sparsity_triplet__0 = casadi__Sparsity__triplet__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__triplet__1" c_casadi__Sparsity__triplet__1 + :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr Sparsity') +casadi__Sparsity__triplet__1 + :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity +casadi__Sparsity__triplet__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__triplet__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_triplet__1 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> IO Sparsity +sparsity_triplet__1 = casadi__Sparsity__triplet__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__triplet__2" c_casadi__Sparsity__triplet__2 + :: Ptr (Ptr StdString) -> CInt -> CInt -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__triplet__2 + :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity +casadi__Sparsity__triplet__2 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__triplet__2 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_triplet__2 :: Int -> Int -> Vector Int -> Vector Int -> Vector Int -> Bool -> IO Sparsity +sparsity_triplet__2 = casadi__Sparsity__triplet__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__0" c_casadi__Sparsity__unidirectionalColoring__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__unidirectionalColoring__0 + :: Sparsity -> IO Sparsity +casadi__Sparsity__unidirectionalColoring__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__unidirectionalColoring__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_unidirectionalColoring__0 :: SparsityClass a => a -> IO Sparsity +sparsity_unidirectionalColoring__0 x = casadi__Sparsity__unidirectionalColoring__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__1" c_casadi__Sparsity__unidirectionalColoring__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__unidirectionalColoring__1 + :: Sparsity -> Sparsity -> IO Sparsity +casadi__Sparsity__unidirectionalColoring__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__unidirectionalColoring__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_unidirectionalColoring__1 :: SparsityClass a => a -> Sparsity -> IO Sparsity +sparsity_unidirectionalColoring__1 x = casadi__Sparsity__unidirectionalColoring__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__unidirectionalColoring__2" c_casadi__Sparsity__unidirectionalColoring__2 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__unidirectionalColoring__2 + :: Sparsity -> Sparsity -> Int -> IO Sparsity +casadi__Sparsity__unidirectionalColoring__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__unidirectionalColoring__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_unidirectionalColoring__2 :: SparsityClass a => a -> Sparsity -> Int -> IO Sparsity +sparsity_unidirectionalColoring__2 x = casadi__Sparsity__unidirectionalColoring__2 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__unit" c_casadi__Sparsity__unit + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__unit + :: Int -> Int -> IO Sparsity +casadi__Sparsity__unit x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__unit errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_unit :: Int -> Int -> IO Sparsity +sparsity_unit = casadi__Sparsity__unit + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__upper" c_casadi__Sparsity__upper + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__upper + :: Int -> IO Sparsity +casadi__Sparsity__upper x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__upper errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_upper :: Int -> IO Sparsity +sparsity_upper = casadi__Sparsity__upper + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__zz_tril__0" c_casadi__Sparsity__zz_tril__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__zz_tril__0 + :: Sparsity -> IO Sparsity +casadi__Sparsity__zz_tril__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__zz_tril__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_zz_tril__0 :: SparsityClass a => a -> IO Sparsity +sparsity_zz_tril__0 x = casadi__Sparsity__zz_tril__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__zz_tril__1" c_casadi__Sparsity__zz_tril__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__zz_tril__1 + :: Sparsity -> Bool -> IO Sparsity +casadi__Sparsity__zz_tril__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__zz_tril__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_zz_tril__1 :: SparsityClass a => a -> Bool -> IO Sparsity +sparsity_zz_tril__1 x = casadi__Sparsity__zz_tril__1 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__zz_triu__0" c_casadi__Sparsity__zz_triu__0 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi__Sparsity__zz_triu__0 + :: Sparsity -> IO Sparsity +casadi__Sparsity__zz_triu__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__zz_triu__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_zz_triu__0 :: SparsityClass a => a -> IO Sparsity +sparsity_zz_triu__0 x = casadi__Sparsity__zz_triu__0 (castSparsity x) + + +-- direct wrapper +foreign import ccall unsafe "casadi__Sparsity__zz_triu__1" c_casadi__Sparsity__zz_triu__1 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi__Sparsity__zz_triu__1 + :: Sparsity -> Bool -> IO Sparsity +casadi__Sparsity__zz_triu__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Sparsity__zz_triu__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +sparsity_zz_triu__1 :: SparsityClass a => a -> Bool -> IO Sparsity +sparsity_zz_triu__1 x = casadi__Sparsity__zz_triu__1 (castSparsity x) diff --git a/Casadi/Core/Classes/SparsityInterfaceCommon.hs b/Casadi/Core/Classes/SparsityInterfaceCommon.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/SparsityInterfaceCommon.hs @@ -0,0 +1,31 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.SparsityInterfaceCommon + ( + SparsityInterfaceCommon, + SparsityInterfaceCommonClass(..), + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums diff --git a/Casadi/Core/Classes/StabilizedQpSolver.hs b/Casadi/Core/Classes/StabilizedQpSolver.hs --- a/Casadi/Core/Classes/StabilizedQpSolver.hs +++ b/Casadi/Core/Classes/StabilizedQpSolver.hs @@ -9,18 +9,20 @@ ( StabilizedQpSolver, StabilizedQpSolverClass(..), - stabilizedQpSolver, + stabilizedQpSolver__0, + stabilizedQpSolver__1, + stabilizedQpSolver__2, stabilizedQpSolver_doc, stabilizedQpSolver_generateNativeCode, stabilizedQpSolver_hasPlugin, stabilizedQpSolver_loadPlugin, - stabilizedQpSolver_setLPOptions, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -28,31 +30,75 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper -foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR" c_casadi__StabilizedQpSolver__CONSTRUCTOR +foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR__0" c_casadi__StabilizedQpSolver__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> IO (Ptr StabilizedQpSolver') +casadi__StabilizedQpSolver__CONSTRUCTOR__0 + :: String -> String -> M.Map String Sparsity -> IO StabilizedQpSolver +casadi__StabilizedQpSolver__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__StabilizedQpSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +stabilizedQpSolver__0 :: String -> String -> M.Map String Sparsity -> IO StabilizedQpSolver +stabilizedQpSolver__0 = casadi__StabilizedQpSolver__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR__1" c_casadi__StabilizedQpSolver__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr Sparsity')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr StabilizedQpSolver') +casadi__StabilizedQpSolver__CONSTRUCTOR__1 + :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO StabilizedQpSolver +casadi__StabilizedQpSolver__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__StabilizedQpSolver__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +stabilizedQpSolver__1 :: String -> String -> M.Map String Sparsity -> M.Map String GenericType -> IO StabilizedQpSolver +stabilizedQpSolver__1 = casadi__StabilizedQpSolver__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR__2" c_casadi__StabilizedQpSolver__CONSTRUCTOR__2 :: Ptr (Ptr StdString) -> IO (Ptr StabilizedQpSolver') -casadi__StabilizedQpSolver__CONSTRUCTOR +casadi__StabilizedQpSolver__CONSTRUCTOR__2 :: IO StabilizedQpSolver -casadi__StabilizedQpSolver__CONSTRUCTOR = +casadi__StabilizedQpSolver__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__StabilizedQpSolver__CONSTRUCTOR errStrPtrP + ret <- c_casadi__StabilizedQpSolver__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -stabilizedQpSolver :: IO StabilizedQpSolver -stabilizedQpSolver = casadi__StabilizedQpSolver__CONSTRUCTOR +stabilizedQpSolver__2 :: IO StabilizedQpSolver +stabilizedQpSolver__2 = casadi__StabilizedQpSolver__CONSTRUCTOR__2 -- direct wrapper @@ -134,24 +180,4 @@ -- classy wrapper stabilizedQpSolver_loadPlugin :: String -> IO () stabilizedQpSolver_loadPlugin = casadi__StabilizedQpSolver__loadPlugin - - --- direct wrapper -foreign import ccall unsafe "casadi__StabilizedQpSolver__setLPOptions" c_casadi__StabilizedQpSolver__setLPOptions - :: Ptr (Ptr StdString) -> Ptr StabilizedQpSolver' -> IO () -casadi__StabilizedQpSolver__setLPOptions - :: StabilizedQpSolver -> IO () -casadi__StabilizedQpSolver__setLPOptions x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__StabilizedQpSolver__setLPOptions errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -stabilizedQpSolver_setLPOptions :: StabilizedQpSolverClass a => a -> IO () -stabilizedQpSolver_setLPOptions x = casadi__StabilizedQpSolver__setLPOptions (castStabilizedQpSolver x) diff --git a/Casadi/Core/Classes/Switch.hs b/Casadi/Core/Classes/Switch.hs new file mode 100644 --- /dev/null +++ b/Casadi/Core/Classes/Switch.hs @@ -0,0 +1,145 @@ +{-# OPTIONS_GHC -Wall #-} +{-# OPTIONS_GHC -fno-warn-unused-imports #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} +{-# Language ForeignFunctionInterface #-} +{-# Language FlexibleInstances #-} +{-# Language MultiParamTypeClasses #-} + +module Casadi.Core.Classes.Switch + ( + Switch, + SwitchClass(..), + switch__0, + switch__1, + switch__2, + switch__3, + switch__4, + ) where + + +import Prelude hiding ( Functor ) + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) +import Foreign.ForeignPtr ( newForeignPtr ) +import System.IO.Unsafe ( unsafePerformIO ) -- for show instances + +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' +import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +import Casadi.Core.Data +import Casadi.Core.Enums +-- direct wrapper +foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__0" c_casadi__Switch__CONSTRUCTOR__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> IO (Ptr Switch') +casadi__Switch__CONSTRUCTOR__0 + :: String -> Function -> Function -> IO Switch +casadi__Switch__CONSTRUCTOR__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Switch__CONSTRUCTOR__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +switch__0 :: String -> Function -> Function -> IO Switch +switch__0 = casadi__Switch__CONSTRUCTOR__0 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__1" c_casadi__Switch__CONSTRUCTOR__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Function' -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Switch') +casadi__Switch__CONSTRUCTOR__1 + :: String -> Function -> Function -> M.Map String GenericType -> IO Switch +casadi__Switch__CONSTRUCTOR__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Switch__CONSTRUCTOR__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +switch__1 :: String -> Function -> Function -> M.Map String GenericType -> IO Switch +switch__1 = casadi__Switch__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__2" c_casadi__Switch__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Function')) -> Ptr Function' -> IO (Ptr Switch') +casadi__Switch__CONSTRUCTOR__2 + :: String -> Vector Function -> Function -> IO Switch +casadi__Switch__CONSTRUCTOR__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Switch__CONSTRUCTOR__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +switch__2 :: String -> Vector Function -> Function -> IO Switch +switch__2 = casadi__Switch__CONSTRUCTOR__2 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__3" c_casadi__Switch__CONSTRUCTOR__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Function')) -> Ptr Function' -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr Switch') +casadi__Switch__CONSTRUCTOR__3 + :: String -> Vector Function -> Function -> M.Map String GenericType -> IO Switch +casadi__Switch__CONSTRUCTOR__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Switch__CONSTRUCTOR__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +switch__3 :: String -> Vector Function -> Function -> M.Map String GenericType -> IO Switch +switch__3 = casadi__Switch__CONSTRUCTOR__3 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Switch__CONSTRUCTOR__4" c_casadi__Switch__CONSTRUCTOR__4 + :: Ptr (Ptr StdString) -> IO (Ptr Switch') +casadi__Switch__CONSTRUCTOR__4 + :: IO Switch +casadi__Switch__CONSTRUCTOR__4 = + + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Switch__CONSTRUCTOR__4 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +switch__4 :: IO Switch +switch__4 = casadi__Switch__CONSTRUCTOR__4 + diff --git a/Casadi/Core/Classes/SymbolicNLP.hs b/Casadi/Core/Classes/SymbolicNLP.hs deleted file mode 100644 --- a/Casadi/Core/Classes/SymbolicNLP.hs +++ /dev/null @@ -1,94 +0,0 @@ -{-# OPTIONS_GHC -Wall #-} -{-# OPTIONS_GHC -fno-warn-unused-imports #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# Language ForeignFunctionInterface #-} -{-# Language FlexibleInstances #-} -{-# Language MultiParamTypeClasses #-} - -module Casadi.Core.Classes.SymbolicNLP - ( - SymbolicNLP, - SymbolicNLPClass(..), - symbolicNLP_getDescription, - symbolicNLP_getRepresentation, - symbolicNLP_parseNL, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicNLP__parseNL" c_casadi__SymbolicNLP__parseNL - :: Ptr (Ptr StdString) -> Ptr SymbolicNLP' -> Ptr StdString -> IO () -casadi__SymbolicNLP__parseNL - :: SymbolicNLP -> String -> IO () -casadi__SymbolicNLP__parseNL x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicNLP__parseNL errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicNLP_parseNL :: SymbolicNLPClass a => a -> String -> IO () -symbolicNLP_parseNL x = casadi__SymbolicNLP__parseNL (castSymbolicNLP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicNLP__getRepresentation" c_casadi__SymbolicNLP__getRepresentation - :: Ptr (Ptr StdString) -> Ptr SymbolicNLP' -> IO (Ptr StdString) -casadi__SymbolicNLP__getRepresentation - :: SymbolicNLP -> IO String -casadi__SymbolicNLP__getRepresentation x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicNLP__getRepresentation errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicNLP_getRepresentation :: SymbolicNLPClass a => a -> IO String -symbolicNLP_getRepresentation x = casadi__SymbolicNLP__getRepresentation (castSymbolicNLP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicNLP__getDescription" c_casadi__SymbolicNLP__getDescription - :: Ptr (Ptr StdString) -> Ptr SymbolicNLP' -> IO (Ptr StdString) -casadi__SymbolicNLP__getDescription - :: SymbolicNLP -> IO String -casadi__SymbolicNLP__getDescription x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicNLP__getDescription errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicNLP_getDescription :: SymbolicNLPClass a => a -> IO String -symbolicNLP_getDescription x = casadi__SymbolicNLP__getDescription (castSymbolicNLP x) - diff --git a/Casadi/Core/Classes/SymbolicOCP.hs b/Casadi/Core/Classes/SymbolicOCP.hs deleted file mode 100644 --- a/Casadi/Core/Classes/SymbolicOCP.hs +++ /dev/null @@ -1,1882 +0,0 @@ -{-# OPTIONS_GHC -Wall #-} -{-# OPTIONS_GHC -fno-warn-unused-imports #-} -{-# OPTIONS_GHC -fno-warn-orphans #-} -{-# Language ForeignFunctionInterface #-} -{-# Language FlexibleInstances #-} -{-# Language MultiParamTypeClasses #-} - -module Casadi.Core.Classes.SymbolicOCP - ( - SymbolicOCP, - SymbolicOCPClass(..), - symbolicOCP, - symbolicOCP_addVariable__0, - symbolicOCP_addVariable__1, - symbolicOCP_add_alg, - symbolicOCP_add_dae, - symbolicOCP_add_ode, - symbolicOCP_add_p, - symbolicOCP_add_u, - symbolicOCP_add_x, - symbolicOCP_add_z, - symbolicOCP_der__0, - symbolicOCP_der__1, - symbolicOCP_derivativeStart__0, - symbolicOCP_derivativeStart__1, - symbolicOCP_derivativeStart__2, - symbolicOCP_derivativeStart__3, - symbolicOCP_eliminate_alg, - symbolicOCP_eliminate_i, - symbolicOCP_eliminate_lterm, - symbolicOCP_eliminate_quad, - symbolicOCP_generateCode, - symbolicOCP_generateHeader__0, - symbolicOCP_generateHeader__1, - symbolicOCP_generateMuscodDatFile, - symbolicOCP_getDescription, - symbolicOCP_getRepresentation, - symbolicOCP_initialGuess__0, - symbolicOCP_initialGuess__1, - symbolicOCP_initialGuess__2, - symbolicOCP_initialGuess__3, - symbolicOCP_makeExplicit, - symbolicOCP_makeSemiExplicit, - symbolicOCP_max__0, - symbolicOCP_max__1, - symbolicOCP_max__2, - symbolicOCP_max__3, - symbolicOCP_min__0, - symbolicOCP_min__1, - symbolicOCP_min__2, - symbolicOCP_min__3, - symbolicOCP_nominal__0, - symbolicOCP_nominal__1, - symbolicOCP_operator_call, - symbolicOCP_parseFMI, - symbolicOCP_sanityCheck, - symbolicOCP_scaleEquations, - symbolicOCP_scaleVariables, - symbolicOCP_setDerivativeStart__0, - symbolicOCP_setDerivativeStart__1, - symbolicOCP_setDerivativeStart__2, - symbolicOCP_setDerivativeStart__3, - symbolicOCP_setInitialGuess__0, - symbolicOCP_setInitialGuess__1, - symbolicOCP_setInitialGuess__2, - symbolicOCP_setInitialGuess__3, - symbolicOCP_setMax__0, - symbolicOCP_setMax__1, - symbolicOCP_setMax__2, - symbolicOCP_setMax__3, - symbolicOCP_setMin__0, - symbolicOCP_setMin__1, - symbolicOCP_setMin__2, - symbolicOCP_setMin__3, - symbolicOCP_setNominal__0, - symbolicOCP_setNominal__1, - symbolicOCP_setStart__0, - symbolicOCP_setStart__1, - symbolicOCP_setStart__2, - symbolicOCP_setStart__3, - symbolicOCP_setUnit, - symbolicOCP_sort_alg, - symbolicOCP_sort_dae, - symbolicOCP_sort_i, - symbolicOCP_split_dae, - symbolicOCP_split_i, - symbolicOCP_start__0, - symbolicOCP_start__1, - symbolicOCP_start__2, - symbolicOCP_start__3, - symbolicOCP_unit__0, - symbolicOCP_unit__1, - symbolicOCP_variable__0, - symbolicOCP_variable__1, - ) where - - -import Prelude hiding ( Functor ) - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) -import Foreign.ForeignPtr ( newForeignPtr ) -import System.IO.Unsafe ( unsafePerformIO ) -- for show instances - -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' -import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -import Casadi.Core.Data -import Casadi.Core.Enums --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__CONSTRUCTOR" c_casadi__SymbolicOCP__CONSTRUCTOR - :: Ptr (Ptr StdString) -> IO (Ptr SymbolicOCP') -casadi__SymbolicOCP__CONSTRUCTOR - :: IO SymbolicOCP -casadi__SymbolicOCP__CONSTRUCTOR = - - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__CONSTRUCTOR errStrPtrP - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP :: IO SymbolicOCP -symbolicOCP = casadi__SymbolicOCP__CONSTRUCTOR - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__addVariable__0" c_casadi__SymbolicOCP__addVariable__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX') -casadi__SymbolicOCP__addVariable__0 - :: SymbolicOCP -> String -> IO SX -casadi__SymbolicOCP__addVariable__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__addVariable__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_addVariable__0 :: SymbolicOCPClass a => a -> String -> IO SX -symbolicOCP_addVariable__0 x = casadi__SymbolicOCP__addVariable__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__addVariable__1" c_casadi__SymbolicOCP__addVariable__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> Ptr Variable' -> IO () -casadi__SymbolicOCP__addVariable__1 - :: SymbolicOCP -> String -> Variable -> IO () -casadi__SymbolicOCP__addVariable__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__addVariable__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_addVariable__1 :: SymbolicOCPClass a => a -> String -> Variable -> IO () -symbolicOCP_addVariable__1 x = casadi__SymbolicOCP__addVariable__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__add_alg" c_casadi__SymbolicOCP__add_alg - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO () -casadi__SymbolicOCP__add_alg - :: SymbolicOCP -> SX -> IO () -casadi__SymbolicOCP__add_alg x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__add_alg errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_add_alg :: SymbolicOCPClass a => a -> SX -> IO () -symbolicOCP_add_alg x = casadi__SymbolicOCP__add_alg (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__add_dae" c_casadi__SymbolicOCP__add_dae - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO () -casadi__SymbolicOCP__add_dae - :: SymbolicOCP -> SX -> IO () -casadi__SymbolicOCP__add_dae x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__add_dae errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_add_dae :: SymbolicOCPClass a => a -> SX -> IO () -symbolicOCP_add_dae x = casadi__SymbolicOCP__add_dae (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__add_ode" c_casadi__SymbolicOCP__add_ode - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO () -casadi__SymbolicOCP__add_ode - :: SymbolicOCP -> SX -> IO () -casadi__SymbolicOCP__add_ode x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__add_ode errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_add_ode :: SymbolicOCPClass a => a -> SX -> IO () -symbolicOCP_add_ode x = casadi__SymbolicOCP__add_ode (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__add_p" c_casadi__SymbolicOCP__add_p - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX') -casadi__SymbolicOCP__add_p - :: SymbolicOCP -> String -> IO SX -casadi__SymbolicOCP__add_p x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__add_p errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_add_p :: SymbolicOCPClass a => a -> String -> IO SX -symbolicOCP_add_p x = casadi__SymbolicOCP__add_p (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__add_u" c_casadi__SymbolicOCP__add_u - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX') -casadi__SymbolicOCP__add_u - :: SymbolicOCP -> String -> IO SX -casadi__SymbolicOCP__add_u x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__add_u errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_add_u :: SymbolicOCPClass a => a -> String -> IO SX -symbolicOCP_add_u x = casadi__SymbolicOCP__add_u (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__add_x" c_casadi__SymbolicOCP__add_x - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX') -casadi__SymbolicOCP__add_x - :: SymbolicOCP -> String -> IO SX -casadi__SymbolicOCP__add_x x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__add_x errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_add_x :: SymbolicOCPClass a => a -> String -> IO SX -symbolicOCP_add_x x = casadi__SymbolicOCP__add_x (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__add_z" c_casadi__SymbolicOCP__add_z - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX') -casadi__SymbolicOCP__add_z - :: SymbolicOCP -> String -> IO SX -casadi__SymbolicOCP__add_z x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__add_z errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_add_z :: SymbolicOCPClass a => a -> String -> IO SX -symbolicOCP_add_z x = casadi__SymbolicOCP__add_z (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__der__0" c_casadi__SymbolicOCP__der__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX') -casadi__SymbolicOCP__der__0 - :: SymbolicOCP -> SX -> IO SX -casadi__SymbolicOCP__der__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__der__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_der__0 :: SymbolicOCPClass a => a -> SX -> IO SX -symbolicOCP_der__0 x = casadi__SymbolicOCP__der__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__der__1" c_casadi__SymbolicOCP__der__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX') -casadi__SymbolicOCP__der__1 - :: SymbolicOCP -> String -> IO SX -casadi__SymbolicOCP__der__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__der__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_der__1 :: SymbolicOCPClass a => a -> String -> IO SX -symbolicOCP_der__1 x = casadi__SymbolicOCP__der__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__0" c_casadi__SymbolicOCP__derivativeStart__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__derivativeStart__0 - :: SymbolicOCP -> SX -> IO (Vector Double) -casadi__SymbolicOCP__derivativeStart__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__derivativeStart__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_derivativeStart__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double) -symbolicOCP_derivativeStart__0 x = casadi__SymbolicOCP__derivativeStart__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__1" c_casadi__SymbolicOCP__derivativeStart__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__derivativeStart__1 - :: SymbolicOCP -> SX -> Bool -> IO (Vector Double) -casadi__SymbolicOCP__derivativeStart__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__derivativeStart__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_derivativeStart__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double) -symbolicOCP_derivativeStart__1 x = casadi__SymbolicOCP__derivativeStart__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__2" c_casadi__SymbolicOCP__derivativeStart__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble -casadi__SymbolicOCP__derivativeStart__2 - :: SymbolicOCP -> String -> IO Double -casadi__SymbolicOCP__derivativeStart__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__derivativeStart__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_derivativeStart__2 :: SymbolicOCPClass a => a -> String -> IO Double -symbolicOCP_derivativeStart__2 x = casadi__SymbolicOCP__derivativeStart__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__derivativeStart__3" c_casadi__SymbolicOCP__derivativeStart__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble -casadi__SymbolicOCP__derivativeStart__3 - :: SymbolicOCP -> String -> Bool -> IO Double -casadi__SymbolicOCP__derivativeStart__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__derivativeStart__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_derivativeStart__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double -symbolicOCP_derivativeStart__3 x = casadi__SymbolicOCP__derivativeStart__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_alg" c_casadi__SymbolicOCP__eliminate_alg - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__eliminate_alg - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__eliminate_alg x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__eliminate_alg errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_eliminate_alg :: SymbolicOCPClass a => a -> IO () -symbolicOCP_eliminate_alg x = casadi__SymbolicOCP__eliminate_alg (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_i" c_casadi__SymbolicOCP__eliminate_i - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__eliminate_i - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__eliminate_i x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__eliminate_i errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_eliminate_i :: SymbolicOCPClass a => a -> IO () -symbolicOCP_eliminate_i x = casadi__SymbolicOCP__eliminate_i (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_lterm" c_casadi__SymbolicOCP__eliminate_lterm - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__eliminate_lterm - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__eliminate_lterm x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__eliminate_lterm errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_eliminate_lterm :: SymbolicOCPClass a => a -> IO () -symbolicOCP_eliminate_lterm x = casadi__SymbolicOCP__eliminate_lterm (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__eliminate_quad" c_casadi__SymbolicOCP__eliminate_quad - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__eliminate_quad - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__eliminate_quad x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__eliminate_quad errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_eliminate_quad :: SymbolicOCPClass a => a -> IO () -symbolicOCP_eliminate_quad x = casadi__SymbolicOCP__eliminate_quad (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__generateCode" c_casadi__SymbolicOCP__generateCode - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO () -casadi__SymbolicOCP__generateCode - :: SymbolicOCP -> String -> IO () -casadi__SymbolicOCP__generateCode x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__generateCode errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_generateCode :: SymbolicOCPClass a => a -> String -> IO () -symbolicOCP_generateCode x = casadi__SymbolicOCP__generateCode (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__generateHeader__0" c_casadi__SymbolicOCP__generateHeader__0 - :: Ptr (Ptr StdString) -> Ptr StdString -> IO () -casadi__SymbolicOCP__generateHeader__0 - :: String -> IO () -casadi__SymbolicOCP__generateHeader__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__generateHeader__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_generateHeader__0 :: String -> IO () -symbolicOCP_generateHeader__0 = casadi__SymbolicOCP__generateHeader__0 - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__generateHeader__1" c_casadi__SymbolicOCP__generateHeader__1 - :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO () -casadi__SymbolicOCP__generateHeader__1 - :: String -> String -> IO () -casadi__SymbolicOCP__generateHeader__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__generateHeader__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_generateHeader__1 :: String -> String -> IO () -symbolicOCP_generateHeader__1 = casadi__SymbolicOCP__generateHeader__1 - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__generateMuscodDatFile" c_casadi__SymbolicOCP__generateMuscodDatFile - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO () -casadi__SymbolicOCP__generateMuscodDatFile - :: SymbolicOCP -> String -> IO () -casadi__SymbolicOCP__generateMuscodDatFile x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__generateMuscodDatFile errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_generateMuscodDatFile :: SymbolicOCPClass a => a -> String -> IO () -symbolicOCP_generateMuscodDatFile x = casadi__SymbolicOCP__generateMuscodDatFile (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__0" c_casadi__SymbolicOCP__initialGuess__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__initialGuess__0 - :: SymbolicOCP -> SX -> IO (Vector Double) -casadi__SymbolicOCP__initialGuess__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__initialGuess__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_initialGuess__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double) -symbolicOCP_initialGuess__0 x = casadi__SymbolicOCP__initialGuess__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__1" c_casadi__SymbolicOCP__initialGuess__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__initialGuess__1 - :: SymbolicOCP -> SX -> Bool -> IO (Vector Double) -casadi__SymbolicOCP__initialGuess__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__initialGuess__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_initialGuess__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double) -symbolicOCP_initialGuess__1 x = casadi__SymbolicOCP__initialGuess__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__2" c_casadi__SymbolicOCP__initialGuess__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble -casadi__SymbolicOCP__initialGuess__2 - :: SymbolicOCP -> String -> IO Double -casadi__SymbolicOCP__initialGuess__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__initialGuess__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_initialGuess__2 :: SymbolicOCPClass a => a -> String -> IO Double -symbolicOCP_initialGuess__2 x = casadi__SymbolicOCP__initialGuess__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__initialGuess__3" c_casadi__SymbolicOCP__initialGuess__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble -casadi__SymbolicOCP__initialGuess__3 - :: SymbolicOCP -> String -> Bool -> IO Double -casadi__SymbolicOCP__initialGuess__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__initialGuess__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_initialGuess__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double -symbolicOCP_initialGuess__3 x = casadi__SymbolicOCP__initialGuess__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__makeExplicit" c_casadi__SymbolicOCP__makeExplicit - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__makeExplicit - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__makeExplicit x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__makeExplicit errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_makeExplicit :: SymbolicOCPClass a => a -> IO () -symbolicOCP_makeExplicit x = casadi__SymbolicOCP__makeExplicit (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__makeSemiExplicit" c_casadi__SymbolicOCP__makeSemiExplicit - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__makeSemiExplicit - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__makeSemiExplicit x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__makeSemiExplicit errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_makeSemiExplicit :: SymbolicOCPClass a => a -> IO () -symbolicOCP_makeSemiExplicit x = casadi__SymbolicOCP__makeSemiExplicit (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__max__0" c_casadi__SymbolicOCP__max__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__max__0 - :: SymbolicOCP -> SX -> IO (Vector Double) -casadi__SymbolicOCP__max__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__max__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_max__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double) -symbolicOCP_max__0 x = casadi__SymbolicOCP__max__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__max__1" c_casadi__SymbolicOCP__max__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__max__1 - :: SymbolicOCP -> SX -> Bool -> IO (Vector Double) -casadi__SymbolicOCP__max__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__max__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_max__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double) -symbolicOCP_max__1 x = casadi__SymbolicOCP__max__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__max__2" c_casadi__SymbolicOCP__max__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble -casadi__SymbolicOCP__max__2 - :: SymbolicOCP -> String -> IO Double -casadi__SymbolicOCP__max__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__max__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_max__2 :: SymbolicOCPClass a => a -> String -> IO Double -symbolicOCP_max__2 x = casadi__SymbolicOCP__max__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__max__3" c_casadi__SymbolicOCP__max__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble -casadi__SymbolicOCP__max__3 - :: SymbolicOCP -> String -> Bool -> IO Double -casadi__SymbolicOCP__max__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__max__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_max__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double -symbolicOCP_max__3 x = casadi__SymbolicOCP__max__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__min__0" c_casadi__SymbolicOCP__min__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__min__0 - :: SymbolicOCP -> SX -> IO (Vector Double) -casadi__SymbolicOCP__min__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__min__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_min__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double) -symbolicOCP_min__0 x = casadi__SymbolicOCP__min__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__min__1" c_casadi__SymbolicOCP__min__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__min__1 - :: SymbolicOCP -> SX -> Bool -> IO (Vector Double) -casadi__SymbolicOCP__min__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__min__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_min__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double) -symbolicOCP_min__1 x = casadi__SymbolicOCP__min__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__min__2" c_casadi__SymbolicOCP__min__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble -casadi__SymbolicOCP__min__2 - :: SymbolicOCP -> String -> IO Double -casadi__SymbolicOCP__min__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__min__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_min__2 :: SymbolicOCPClass a => a -> String -> IO Double -symbolicOCP_min__2 x = casadi__SymbolicOCP__min__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__min__3" c_casadi__SymbolicOCP__min__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble -casadi__SymbolicOCP__min__3 - :: SymbolicOCP -> String -> Bool -> IO Double -casadi__SymbolicOCP__min__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__min__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_min__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double -symbolicOCP_min__3 x = casadi__SymbolicOCP__min__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__nominal__0" c_casadi__SymbolicOCP__nominal__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__nominal__0 - :: SymbolicOCP -> SX -> IO (Vector Double) -casadi__SymbolicOCP__nominal__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__nominal__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_nominal__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double) -symbolicOCP_nominal__0 x = casadi__SymbolicOCP__nominal__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__nominal__1" c_casadi__SymbolicOCP__nominal__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble -casadi__SymbolicOCP__nominal__1 - :: SymbolicOCP -> String -> IO Double -casadi__SymbolicOCP__nominal__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__nominal__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_nominal__1 :: SymbolicOCPClass a => a -> String -> IO Double -symbolicOCP_nominal__1 x = casadi__SymbolicOCP__nominal__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__operator_call" c_casadi__SymbolicOCP__operator_call - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX') -casadi__SymbolicOCP__operator_call - :: SymbolicOCP -> String -> IO SX -casadi__SymbolicOCP__operator_call x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__operator_call errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_operator_call :: SymbolicOCPClass a => a -> String -> IO SX -symbolicOCP_operator_call x = casadi__SymbolicOCP__operator_call (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__parseFMI" c_casadi__SymbolicOCP__parseFMI - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO () -casadi__SymbolicOCP__parseFMI - :: SymbolicOCP -> String -> IO () -casadi__SymbolicOCP__parseFMI x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__parseFMI errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_parseFMI :: SymbolicOCPClass a => a -> String -> IO () -symbolicOCP_parseFMI x = casadi__SymbolicOCP__parseFMI (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__sanityCheck" c_casadi__SymbolicOCP__sanityCheck - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__sanityCheck - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__sanityCheck x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__sanityCheck errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_sanityCheck :: SymbolicOCPClass a => a -> IO () -symbolicOCP_sanityCheck x = casadi__SymbolicOCP__sanityCheck (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__scaleEquations" c_casadi__SymbolicOCP__scaleEquations - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__scaleEquations - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__scaleEquations x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__scaleEquations errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_scaleEquations :: SymbolicOCPClass a => a -> IO () -symbolicOCP_scaleEquations x = casadi__SymbolicOCP__scaleEquations (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__scaleVariables" c_casadi__SymbolicOCP__scaleVariables - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__scaleVariables - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__scaleVariables x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__scaleVariables errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_scaleVariables :: SymbolicOCPClass a => a -> IO () -symbolicOCP_scaleVariables x = casadi__SymbolicOCP__scaleVariables (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__0" c_casadi__SymbolicOCP__setDerivativeStart__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SymbolicOCP__setDerivativeStart__0 - :: SymbolicOCP -> SX -> Vector Double -> IO () -casadi__SymbolicOCP__setDerivativeStart__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setDerivativeStart__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setDerivativeStart__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO () -symbolicOCP_setDerivativeStart__0 x = casadi__SymbolicOCP__setDerivativeStart__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__1" c_casadi__SymbolicOCP__setDerivativeStart__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__SymbolicOCP__setDerivativeStart__1 - :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO () -casadi__SymbolicOCP__setDerivativeStart__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setDerivativeStart__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setDerivativeStart__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO () -symbolicOCP_setDerivativeStart__1 x = casadi__SymbolicOCP__setDerivativeStart__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__2" c_casadi__SymbolicOCP__setDerivativeStart__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO () -casadi__SymbolicOCP__setDerivativeStart__2 - :: SymbolicOCP -> String -> Double -> IO () -casadi__SymbolicOCP__setDerivativeStart__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setDerivativeStart__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setDerivativeStart__2 :: SymbolicOCPClass a => a -> String -> Double -> IO () -symbolicOCP_setDerivativeStart__2 x = casadi__SymbolicOCP__setDerivativeStart__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setDerivativeStart__3" c_casadi__SymbolicOCP__setDerivativeStart__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO () -casadi__SymbolicOCP__setDerivativeStart__3 - :: SymbolicOCP -> String -> Double -> Bool -> IO () -casadi__SymbolicOCP__setDerivativeStart__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setDerivativeStart__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setDerivativeStart__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO () -symbolicOCP_setDerivativeStart__3 x = casadi__SymbolicOCP__setDerivativeStart__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__0" c_casadi__SymbolicOCP__setInitialGuess__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SymbolicOCP__setInitialGuess__0 - :: SymbolicOCP -> SX -> Vector Double -> IO () -casadi__SymbolicOCP__setInitialGuess__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setInitialGuess__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setInitialGuess__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO () -symbolicOCP_setInitialGuess__0 x = casadi__SymbolicOCP__setInitialGuess__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__1" c_casadi__SymbolicOCP__setInitialGuess__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__SymbolicOCP__setInitialGuess__1 - :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO () -casadi__SymbolicOCP__setInitialGuess__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setInitialGuess__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setInitialGuess__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO () -symbolicOCP_setInitialGuess__1 x = casadi__SymbolicOCP__setInitialGuess__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__2" c_casadi__SymbolicOCP__setInitialGuess__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO () -casadi__SymbolicOCP__setInitialGuess__2 - :: SymbolicOCP -> String -> Double -> IO () -casadi__SymbolicOCP__setInitialGuess__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setInitialGuess__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setInitialGuess__2 :: SymbolicOCPClass a => a -> String -> Double -> IO () -symbolicOCP_setInitialGuess__2 x = casadi__SymbolicOCP__setInitialGuess__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setInitialGuess__3" c_casadi__SymbolicOCP__setInitialGuess__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO () -casadi__SymbolicOCP__setInitialGuess__3 - :: SymbolicOCP -> String -> Double -> Bool -> IO () -casadi__SymbolicOCP__setInitialGuess__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setInitialGuess__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setInitialGuess__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO () -symbolicOCP_setInitialGuess__3 x = casadi__SymbolicOCP__setInitialGuess__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMax__0" c_casadi__SymbolicOCP__setMax__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SymbolicOCP__setMax__0 - :: SymbolicOCP -> SX -> Vector Double -> IO () -casadi__SymbolicOCP__setMax__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMax__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMax__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO () -symbolicOCP_setMax__0 x = casadi__SymbolicOCP__setMax__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMax__1" c_casadi__SymbolicOCP__setMax__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__SymbolicOCP__setMax__1 - :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO () -casadi__SymbolicOCP__setMax__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMax__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMax__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO () -symbolicOCP_setMax__1 x = casadi__SymbolicOCP__setMax__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMax__2" c_casadi__SymbolicOCP__setMax__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO () -casadi__SymbolicOCP__setMax__2 - :: SymbolicOCP -> String -> Double -> IO () -casadi__SymbolicOCP__setMax__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMax__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMax__2 :: SymbolicOCPClass a => a -> String -> Double -> IO () -symbolicOCP_setMax__2 x = casadi__SymbolicOCP__setMax__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMax__3" c_casadi__SymbolicOCP__setMax__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO () -casadi__SymbolicOCP__setMax__3 - :: SymbolicOCP -> String -> Double -> Bool -> IO () -casadi__SymbolicOCP__setMax__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMax__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMax__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO () -symbolicOCP_setMax__3 x = casadi__SymbolicOCP__setMax__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMin__0" c_casadi__SymbolicOCP__setMin__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SymbolicOCP__setMin__0 - :: SymbolicOCP -> SX -> Vector Double -> IO () -casadi__SymbolicOCP__setMin__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMin__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMin__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO () -symbolicOCP_setMin__0 x = casadi__SymbolicOCP__setMin__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMin__1" c_casadi__SymbolicOCP__setMin__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__SymbolicOCP__setMin__1 - :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO () -casadi__SymbolicOCP__setMin__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMin__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMin__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO () -symbolicOCP_setMin__1 x = casadi__SymbolicOCP__setMin__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMin__2" c_casadi__SymbolicOCP__setMin__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO () -casadi__SymbolicOCP__setMin__2 - :: SymbolicOCP -> String -> Double -> IO () -casadi__SymbolicOCP__setMin__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMin__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMin__2 :: SymbolicOCPClass a => a -> String -> Double -> IO () -symbolicOCP_setMin__2 x = casadi__SymbolicOCP__setMin__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setMin__3" c_casadi__SymbolicOCP__setMin__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO () -casadi__SymbolicOCP__setMin__3 - :: SymbolicOCP -> String -> Double -> Bool -> IO () -casadi__SymbolicOCP__setMin__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setMin__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setMin__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO () -symbolicOCP_setMin__3 x = casadi__SymbolicOCP__setMin__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setNominal__0" c_casadi__SymbolicOCP__setNominal__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SymbolicOCP__setNominal__0 - :: SymbolicOCP -> SX -> Vector Double -> IO () -casadi__SymbolicOCP__setNominal__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setNominal__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setNominal__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO () -symbolicOCP_setNominal__0 x = casadi__SymbolicOCP__setNominal__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setNominal__1" c_casadi__SymbolicOCP__setNominal__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO () -casadi__SymbolicOCP__setNominal__1 - :: SymbolicOCP -> String -> Double -> IO () -casadi__SymbolicOCP__setNominal__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setNominal__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setNominal__1 :: SymbolicOCPClass a => a -> String -> Double -> IO () -symbolicOCP_setNominal__1 x = casadi__SymbolicOCP__setNominal__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setStart__0" c_casadi__SymbolicOCP__setStart__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> IO () -casadi__SymbolicOCP__setStart__0 - :: SymbolicOCP -> SX -> Vector Double -> IO () -casadi__SymbolicOCP__setStart__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setStart__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setStart__0 :: SymbolicOCPClass a => a -> SX -> Vector Double -> IO () -symbolicOCP_setStart__0 x = casadi__SymbolicOCP__setStart__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setStart__1" c_casadi__SymbolicOCP__setStart__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr (StdVec CDouble) -> CInt -> IO () -casadi__SymbolicOCP__setStart__1 - :: SymbolicOCP -> SX -> Vector Double -> Bool -> IO () -casadi__SymbolicOCP__setStart__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setStart__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setStart__1 :: SymbolicOCPClass a => a -> SX -> Vector Double -> Bool -> IO () -symbolicOCP_setStart__1 x = casadi__SymbolicOCP__setStart__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setStart__2" c_casadi__SymbolicOCP__setStart__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO () -casadi__SymbolicOCP__setStart__2 - :: SymbolicOCP -> String -> Double -> IO () -casadi__SymbolicOCP__setStart__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setStart__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setStart__2 :: SymbolicOCPClass a => a -> String -> Double -> IO () -symbolicOCP_setStart__2 x = casadi__SymbolicOCP__setStart__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setStart__3" c_casadi__SymbolicOCP__setStart__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO () -casadi__SymbolicOCP__setStart__3 - :: SymbolicOCP -> String -> Double -> Bool -> IO () -casadi__SymbolicOCP__setStart__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setStart__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setStart__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO () -symbolicOCP_setStart__3 x = casadi__SymbolicOCP__setStart__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__setUnit" c_casadi__SymbolicOCP__setUnit - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> Ptr StdString -> IO () -casadi__SymbolicOCP__setUnit - :: SymbolicOCP -> String -> String -> IO () -casadi__SymbolicOCP__setUnit x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__setUnit errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_setUnit :: SymbolicOCPClass a => a -> String -> String -> IO () -symbolicOCP_setUnit x = casadi__SymbolicOCP__setUnit (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__sort_alg" c_casadi__SymbolicOCP__sort_alg - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__sort_alg - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__sort_alg x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__sort_alg errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_sort_alg :: SymbolicOCPClass a => a -> IO () -symbolicOCP_sort_alg x = casadi__SymbolicOCP__sort_alg (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__sort_dae" c_casadi__SymbolicOCP__sort_dae - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__sort_dae - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__sort_dae x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__sort_dae errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_sort_dae :: SymbolicOCPClass a => a -> IO () -symbolicOCP_sort_dae x = casadi__SymbolicOCP__sort_dae (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__sort_i" c_casadi__SymbolicOCP__sort_i - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__sort_i - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__sort_i x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__sort_i errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_sort_i :: SymbolicOCPClass a => a -> IO () -symbolicOCP_sort_i x = casadi__SymbolicOCP__sort_i (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__split_dae" c_casadi__SymbolicOCP__split_dae - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__split_dae - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__split_dae x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__split_dae errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_split_dae :: SymbolicOCPClass a => a -> IO () -symbolicOCP_split_dae x = casadi__SymbolicOCP__split_dae (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__split_i" c_casadi__SymbolicOCP__split_i - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO () -casadi__SymbolicOCP__split_i - :: SymbolicOCP -> IO () -casadi__SymbolicOCP__split_i x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__split_i errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_split_i :: SymbolicOCPClass a => a -> IO () -symbolicOCP_split_i x = casadi__SymbolicOCP__split_i (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__start__0" c_casadi__SymbolicOCP__start__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__start__0 - :: SymbolicOCP -> SX -> IO (Vector Double) -casadi__SymbolicOCP__start__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__start__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_start__0 :: SymbolicOCPClass a => a -> SX -> IO (Vector Double) -symbolicOCP_start__0 x = casadi__SymbolicOCP__start__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__start__1" c_casadi__SymbolicOCP__start__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> CInt -> IO (Ptr (StdVec CDouble)) -casadi__SymbolicOCP__start__1 - :: SymbolicOCP -> SX -> Bool -> IO (Vector Double) -casadi__SymbolicOCP__start__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__start__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_start__1 :: SymbolicOCPClass a => a -> SX -> Bool -> IO (Vector Double) -symbolicOCP_start__1 x = casadi__SymbolicOCP__start__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__start__2" c_casadi__SymbolicOCP__start__2 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO CDouble -casadi__SymbolicOCP__start__2 - :: SymbolicOCP -> String -> IO Double -casadi__SymbolicOCP__start__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__start__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_start__2 :: SymbolicOCPClass a => a -> String -> IO Double -symbolicOCP_start__2 x = casadi__SymbolicOCP__start__2 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__start__3" c_casadi__SymbolicOCP__start__3 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CInt -> IO CDouble -casadi__SymbolicOCP__start__3 - :: SymbolicOCP -> String -> Bool -> IO Double -casadi__SymbolicOCP__start__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__start__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_start__3 :: SymbolicOCPClass a => a -> String -> Bool -> IO Double -symbolicOCP_start__3 x = casadi__SymbolicOCP__start__3 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__unit__0" c_casadi__SymbolicOCP__unit__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr StdString) -casadi__SymbolicOCP__unit__0 - :: SymbolicOCP -> SX -> IO String -casadi__SymbolicOCP__unit__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__unit__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_unit__0 :: SymbolicOCPClass a => a -> SX -> IO String -symbolicOCP_unit__0 x = casadi__SymbolicOCP__unit__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__unit__1" c_casadi__SymbolicOCP__unit__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr StdString) -casadi__SymbolicOCP__unit__1 - :: SymbolicOCP -> String -> IO String -casadi__SymbolicOCP__unit__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__unit__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_unit__1 :: SymbolicOCPClass a => a -> String -> IO String -symbolicOCP_unit__1 x = casadi__SymbolicOCP__unit__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__variable__0" c_casadi__SymbolicOCP__variable__0 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr Variable') -casadi__SymbolicOCP__variable__0 - :: SymbolicOCP -> String -> IO Variable -casadi__SymbolicOCP__variable__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__variable__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_variable__0 :: SymbolicOCPClass a => a -> String -> IO Variable -symbolicOCP_variable__0 x = casadi__SymbolicOCP__variable__0 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__variable__1" c_casadi__SymbolicOCP__variable__1 - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr Variable') -casadi__SymbolicOCP__variable__1 - :: SymbolicOCP -> String -> IO Variable -casadi__SymbolicOCP__variable__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__variable__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_variable__1 :: SymbolicOCPClass a => a -> String -> IO Variable -symbolicOCP_variable__1 x = casadi__SymbolicOCP__variable__1 (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__getRepresentation" c_casadi__SymbolicOCP__getRepresentation - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO (Ptr StdString) -casadi__SymbolicOCP__getRepresentation - :: SymbolicOCP -> IO String -casadi__SymbolicOCP__getRepresentation x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__getRepresentation errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_getRepresentation :: SymbolicOCPClass a => a -> IO String -symbolicOCP_getRepresentation x = casadi__SymbolicOCP__getRepresentation (castSymbolicOCP x) - - --- direct wrapper -foreign import ccall unsafe "casadi__SymbolicOCP__getDescription" c_casadi__SymbolicOCP__getDescription - :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO (Ptr StdString) -casadi__SymbolicOCP__getDescription - :: SymbolicOCP -> IO String -casadi__SymbolicOCP__getDescription x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__SymbolicOCP__getDescription errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -symbolicOCP_getDescription :: SymbolicOCPClass a => a -> IO String -symbolicOCP_getDescription x = casadi__SymbolicOCP__getDescription (castSymbolicOCP x) - diff --git a/Casadi/Core/Classes/Variable.hs b/Casadi/Core/Classes/Variable.hs --- a/Casadi/Core/Classes/Variable.hs +++ b/Casadi/Core/Classes/Variable.hs @@ -11,6 +11,7 @@ VariableClass(..), variable__0, variable__1, + variable__2, variable_getDescription, variable_getRepresentation, variable_name, @@ -20,6 +21,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -27,9 +29,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data @@ -56,22 +57,43 @@ -- direct wrapper foreign import ccall unsafe "casadi__Variable__CONSTRUCTOR__1" c_casadi__Variable__CONSTRUCTOR__1 - :: Ptr (Ptr StdString) -> IO (Ptr Variable') + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr Variable') casadi__Variable__CONSTRUCTOR__1 + :: String -> Sparsity -> IO Variable +casadi__Variable__CONSTRUCTOR__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi__Variable__CONSTRUCTOR__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +-- classy wrapper +variable__1 :: String -> Sparsity -> IO Variable +variable__1 = casadi__Variable__CONSTRUCTOR__1 + + +-- direct wrapper +foreign import ccall unsafe "casadi__Variable__CONSTRUCTOR__2" c_casadi__Variable__CONSTRUCTOR__2 + :: Ptr (Ptr StdString) -> IO (Ptr Variable') +casadi__Variable__CONSTRUCTOR__2 :: IO Variable -casadi__Variable__CONSTRUCTOR__1 = +casadi__Variable__CONSTRUCTOR__2 = do errStrPtrP <- new nullPtr - ret <- c_casadi__Variable__CONSTRUCTOR__1 errStrPtrP + ret <- c_casadi__Variable__CONSTRUCTOR__2 errStrPtrP errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) -- classy wrapper -variable__1 :: IO Variable -variable__1 = casadi__Variable__CONSTRUCTOR__1 +variable__2 :: IO Variable +variable__2 = casadi__Variable__CONSTRUCTOR__2 -- direct wrapper diff --git a/Casadi/Core/Classes/XmlFile.hs b/Casadi/Core/Classes/XmlFile.hs --- a/Casadi/Core/Classes/XmlFile.hs +++ b/Casadi/Core/Classes/XmlFile.hs @@ -19,6 +19,7 @@ import Prelude hiding ( Functor ) import Data.Vector ( Vector ) +import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) @@ -26,9 +27,8 @@ import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream' +import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data diff --git a/Casadi/Core/CustomWrappers.hs b/Casadi/Core/CustomWrappers.hs --- a/Casadi/Core/CustomWrappers.hs +++ b/Casadi/Core/CustomWrappers.hs @@ -4,7 +4,7 @@ {-# Language MultiParamTypeClasses #-} module Casadi.Core.CustomWrappers - ( function_custom_generateCode + ( -- function_custom_generateCode ) where import Prelude hiding ( Functor ) @@ -14,29 +14,29 @@ import Foreign.Storable ( peek ) import Foreign.Ptr ( Ptr, nullPtr ) -import Casadi.Internal.CToolsInstances ( ) import Casadi.Internal.FormatException ( formatException ) import Casadi.Internal.MarshalTypes ( StdString ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( withMarshal ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data --- direct wrapper -foreign import ccall unsafe "casadi__custom__generateCode" c_casadi__custom__generateCode - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) -casadi__custom__generateCode - :: Function -> Bool -> IO String -casadi__custom__generateCode x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_casadi__custom__generateCode errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - --- classy wrapper -function_custom_generateCode :: FunctionClass a => a -> Bool -> IO String -function_custom_generateCode x = casadi__custom__generateCode (castFunction x) +-- -- direct wrapper +-- #error NO +-- foreign import ccall unsafe "casadi__custom__generateCode" c_casadi__custom__generateCode +-- :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr StdString) +-- casadi__custom__generateCode +-- :: Function -> Bool -> IO String +-- casadi__custom__generateCode x0 x1 = +-- withMarshal x0 $ \x0' -> +-- withMarshal x1 $ \x1' -> +-- do +-- errStrPtrP <- new nullPtr +-- ret <- c_casadi__custom__generateCode errStrPtrP x0' x1' +-- errStrPtr <- peek errStrPtrP +-- free errStrPtrP +-- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) +-- +-- +-- -- classy wrapper +-- function_custom_generateCode :: FunctionClass a => a -> Bool -> IO String +-- function_custom_generateCode x = casadi__custom__generateCode (castFunction x) diff --git a/Casadi/Core/Data.hs b/Casadi/Core/Data.hs --- a/Casadi/Core/Data.hs +++ b/Casadi/Core/Data.hs @@ -43,6 +43,30 @@ -- raw decl +data Callback2' +-- data decl +{-| +-} +newtype Callback2 = Callback2 (ForeignPtr Callback2') +-- typeclass decl +class Callback2Class a where + castCallback2 :: a -> Callback2 +instance Callback2Class Callback2 where + castCallback2 = id + +-- baseclass instances + +-- helper instances +instance Marshal Callback2 (Ptr Callback2') where + marshal (Callback2 x) = return (unsafeForeignPtrToPtr x) + marshalFree (Callback2 x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__Callback2" + c_delete_casadi__Callback2 :: FunPtr (Ptr Callback2' -> IO ()) +instance WrapReturn (Ptr Callback2') Callback2 where + wrapReturn = (fmap Callback2) . (newForeignPtr c_delete_casadi__Callback2) + + +-- raw decl data CasadiMeta' -- data decl {-| @@ -127,6 +151,60 @@ -- raw decl +data CodeGenerator' +-- data decl +{-| +-} +newtype CodeGenerator = CodeGenerator (ForeignPtr CodeGenerator') +-- typeclass decl +class CodeGeneratorClass a where + castCodeGenerator :: a -> CodeGenerator +instance CodeGeneratorClass CodeGenerator where + castCodeGenerator = id + +-- baseclass instances + +-- helper instances +instance Marshal CodeGenerator (Ptr CodeGenerator') where + marshal (CodeGenerator x) = return (unsafeForeignPtrToPtr x) + marshalFree (CodeGenerator x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__CodeGenerator" + c_delete_casadi__CodeGenerator :: FunPtr (Ptr CodeGenerator' -> IO ()) +instance WrapReturn (Ptr CodeGenerator') CodeGenerator where + wrapReturn = (fmap CodeGenerator) . (newForeignPtr c_delete_casadi__CodeGenerator) + + +-- raw decl +data Compiler' +-- data decl +{-| +-} +newtype Compiler = Compiler (ForeignPtr Compiler') +-- typeclass decl +class CompilerClass a where + castCompiler :: a -> Compiler +instance CompilerClass Compiler where + castCompiler = id + +-- baseclass instances +instance OptionsFunctionalityClass Compiler where + castOptionsFunctionality (Compiler x) = OptionsFunctionality (castForeignPtr x) + +instance SharedObjectClass Compiler where + castSharedObject (Compiler x) = SharedObject (castForeignPtr x) + + +-- helper instances +instance Marshal Compiler (Ptr Compiler') where + marshal (Compiler x) = return (unsafeForeignPtrToPtr x) + marshalFree (Compiler x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__Compiler" + c_delete_casadi__Compiler :: FunPtr (Ptr Compiler' -> IO ()) +instance WrapReturn (Ptr Compiler') Compiler where + wrapReturn = (fmap Compiler) . (newForeignPtr c_delete_casadi__Compiler) + + +-- raw decl data ControlSimulator' -- data decl {-| @@ -241,7 +319,19 @@ castDMatrix = id -- baseclass instances +instance GenericExpressionCommonClass DMatrix where + castGenericExpressionCommon (DMatrix x) = GenericExpressionCommon (castForeignPtr x) +instance GenericMatrixCommonClass DMatrix where + castGenericMatrixCommon (DMatrix x) = GenericMatrixCommon (castForeignPtr x) + +instance MatrixCommonClass DMatrix where + castMatrixCommon (DMatrix x) = MatrixCommon (castForeignPtr x) + +instance SparsityInterfaceCommonClass DMatrix where + castSparsityInterfaceCommon (DMatrix x) = SparsityInterfaceCommon (castForeignPtr x) + + -- helper instances instance Marshal DMatrix (Ptr DMatrix') where marshal (DMatrix x) = return (unsafeForeignPtrToPtr x) @@ -253,6 +343,30 @@ -- raw decl +data DaeBuilder' +-- data decl +{-| +-} +newtype DaeBuilder = DaeBuilder (ForeignPtr DaeBuilder') +-- typeclass decl +class DaeBuilderClass a where + castDaeBuilder :: a -> DaeBuilder +instance DaeBuilderClass DaeBuilder where + castDaeBuilder = id + +-- baseclass instances + +-- helper instances +instance Marshal DaeBuilder (Ptr DaeBuilder') where + marshal (DaeBuilder x) = return (unsafeForeignPtrToPtr x) + marshalFree (DaeBuilder x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__DaeBuilder" + c_delete_casadi__DaeBuilder :: FunPtr (Ptr DaeBuilder' -> IO ()) +instance WrapReturn (Ptr DaeBuilder') DaeBuilder where + wrapReturn = (fmap DaeBuilder) . (newForeignPtr c_delete_casadi__DaeBuilder) + + +-- raw decl data DerivativeGenerator' -- data decl {-| @@ -283,6 +397,30 @@ -- raw decl +data DerivativeGenerator2' +-- data decl +{-| +-} +newtype DerivativeGenerator2 = DerivativeGenerator2 (ForeignPtr DerivativeGenerator2') +-- typeclass decl +class DerivativeGenerator2Class a where + castDerivativeGenerator2 :: a -> DerivativeGenerator2 +instance DerivativeGenerator2Class DerivativeGenerator2 where + castDerivativeGenerator2 = id + +-- baseclass instances + +-- helper instances +instance Marshal DerivativeGenerator2 (Ptr DerivativeGenerator2') where + marshal (DerivativeGenerator2 x) = return (unsafeForeignPtrToPtr x) + marshalFree (DerivativeGenerator2 x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__DerivativeGenerator2" + c_delete_casadi__DerivativeGenerator2 :: FunPtr (Ptr DerivativeGenerator2' -> IO ()) +instance WrapReturn (Ptr DerivativeGenerator2') DerivativeGenerator2 where + wrapReturn = (fmap DerivativeGenerator2) . (newForeignPtr c_delete_casadi__DerivativeGenerator2) + + +-- raw decl data DleSolver' -- data decl {-| @@ -451,6 +589,54 @@ -- raw decl +data GenericExpressionCommon' +-- data decl +{-| +-} +newtype GenericExpressionCommon = GenericExpressionCommon (ForeignPtr GenericExpressionCommon') +-- typeclass decl +class GenericExpressionCommonClass a where + castGenericExpressionCommon :: a -> GenericExpressionCommon +instance GenericExpressionCommonClass GenericExpressionCommon where + castGenericExpressionCommon = id + +-- baseclass instances + +-- helper instances +instance Marshal GenericExpressionCommon (Ptr GenericExpressionCommon') where + marshal (GenericExpressionCommon x) = return (unsafeForeignPtrToPtr x) + marshalFree (GenericExpressionCommon x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__GenericExpressionCommon" + c_delete_casadi__GenericExpressionCommon :: FunPtr (Ptr GenericExpressionCommon' -> IO ()) +instance WrapReturn (Ptr GenericExpressionCommon') GenericExpressionCommon where + wrapReturn = (fmap GenericExpressionCommon) . (newForeignPtr c_delete_casadi__GenericExpressionCommon) + + +-- raw decl +data GenericMatrixCommon' +-- data decl +{-| +-} +newtype GenericMatrixCommon = GenericMatrixCommon (ForeignPtr GenericMatrixCommon') +-- typeclass decl +class GenericMatrixCommonClass a where + castGenericMatrixCommon :: a -> GenericMatrixCommon +instance GenericMatrixCommonClass GenericMatrixCommon where + castGenericMatrixCommon = id + +-- baseclass instances + +-- helper instances +instance Marshal GenericMatrixCommon (Ptr GenericMatrixCommon') where + marshal (GenericMatrixCommon x) = return (unsafeForeignPtrToPtr x) + marshalFree (GenericMatrixCommon x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__GenericMatrixCommon" + c_delete_casadi__GenericMatrixCommon :: FunPtr (Ptr GenericMatrixCommon' -> IO ()) +instance WrapReturn (Ptr GenericMatrixCommon') GenericMatrixCommon where + wrapReturn = (fmap GenericMatrixCommon) . (newForeignPtr c_delete_casadi__GenericMatrixCommon) + + +-- raw decl data GenericType' -- data decl {-| @@ -526,7 +712,19 @@ castIMatrix = id -- baseclass instances +instance GenericExpressionCommonClass IMatrix where + castGenericExpressionCommon (IMatrix x) = GenericExpressionCommon (castForeignPtr x) +instance GenericMatrixCommonClass IMatrix where + castGenericMatrixCommon (IMatrix x) = GenericMatrixCommon (castForeignPtr x) + +instance MatrixCommonClass IMatrix where + castMatrixCommon (IMatrix x) = MatrixCommon (castForeignPtr x) + +instance SparsityInterfaceCommonClass IMatrix where + castSparsityInterfaceCommon (IMatrix x) = SparsityInterfaceCommon (castForeignPtr x) + + -- helper instances instance Marshal IMatrix (Ptr IMatrix') where marshal (IMatrix x) = return (unsafeForeignPtrToPtr x) @@ -538,33 +736,6 @@ -- raw decl -data IOScheme' --- data decl -{-| --} -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) - - --- helper instances -instance Marshal IOScheme (Ptr IOScheme') where - marshal (IOScheme x) = return (unsafeForeignPtrToPtr x) - marshalFree (IOScheme x) _ = touchForeignPtr x -foreign import ccall unsafe "&delete_casadi__IOScheme" - c_delete_casadi__IOScheme :: FunPtr (Ptr IOScheme' -> IO ()) -instance WrapReturn (Ptr IOScheme') IOScheme where - wrapReturn = (fmap IOScheme) . (newForeignPtr c_delete_casadi__IOScheme) - - --- raw decl data ImplicitFunction' -- data decl {-| @@ -637,6 +808,66 @@ -- raw decl +data IterationCallback' +-- data decl +{-| +-} +newtype IterationCallback = IterationCallback (ForeignPtr IterationCallback') +-- typeclass decl +class IterationCallbackClass a where + castIterationCallback :: a -> IterationCallback +instance IterationCallbackClass IterationCallback where + castIterationCallback = id + +-- baseclass instances + +-- helper instances +instance Marshal IterationCallback (Ptr IterationCallback') where + marshal (IterationCallback x) = return (unsafeForeignPtrToPtr x) + marshalFree (IterationCallback x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__IterationCallback" + c_delete_casadi__IterationCallback :: FunPtr (Ptr IterationCallback' -> IO ()) +instance WrapReturn (Ptr IterationCallback') IterationCallback where + wrapReturn = (fmap IterationCallback) . (newForeignPtr c_delete_casadi__IterationCallback) + + +-- raw decl +data KernelSum2D' +-- data decl +{-| +-} +newtype KernelSum2D = KernelSum2D (ForeignPtr KernelSum2D') +-- typeclass decl +class KernelSum2DClass a where + castKernelSum2D :: a -> KernelSum2D +instance KernelSum2DClass KernelSum2D where + castKernelSum2D = id + +-- baseclass instances +instance FunctionClass KernelSum2D where + castFunction (KernelSum2D x) = Function (castForeignPtr x) + +instance OptionsFunctionalityClass KernelSum2D where + castOptionsFunctionality (KernelSum2D x) = OptionsFunctionality (castForeignPtr x) + +instance SharedObjectClass KernelSum2D where + castSharedObject (KernelSum2D x) = SharedObject (castForeignPtr x) + +instance IOInterfaceFunctionClass KernelSum2D where + castIOInterfaceFunction (KernelSum2D x) = IOInterfaceFunction (castForeignPtr x) + + +-- helper instances +instance Marshal KernelSum2D (Ptr KernelSum2D') where + marshal (KernelSum2D x) = return (unsafeForeignPtrToPtr x) + marshalFree (KernelSum2D x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__KernelSum2D" + c_delete_casadi__KernelSum2D :: FunPtr (Ptr KernelSum2D' -> IO ()) +instance WrapReturn (Ptr KernelSum2D') KernelSum2D where + wrapReturn = (fmap KernelSum2D) . (newForeignPtr c_delete_casadi__KernelSum2D) + + +-- raw decl data LinearSolver' -- data decl {-| @@ -793,10 +1024,19 @@ castMX = id -- baseclass instances +instance GenericExpressionCommonClass MX where + castGenericExpressionCommon (MX x) = GenericExpressionCommon (castForeignPtr x) + +instance GenericMatrixCommonClass MX where + castGenericMatrixCommon (MX x) = GenericMatrixCommon (castForeignPtr x) + instance SharedObjectClass MX where castSharedObject (MX x) = SharedObject (castForeignPtr x) +instance SparsityInterfaceCommonClass MX where + castSparsityInterfaceCommon (MX x) = SparsityInterfaceCommon (castForeignPtr x) + -- helper instances instance Marshal MX (Ptr MX') where marshal (MX x) = return (unsafeForeignPtrToPtr x) @@ -808,30 +1048,6 @@ -- raw decl -data MXAlgEl' --- data decl -{-| --} -newtype MXAlgEl = MXAlgEl (ForeignPtr MXAlgEl') --- typeclass decl -class MXAlgElClass a where - castMXAlgEl :: a -> MXAlgEl -instance MXAlgElClass MXAlgEl where - castMXAlgEl = id - --- baseclass instances - --- helper instances -instance Marshal MXAlgEl (Ptr MXAlgEl') where - marshal (MXAlgEl x) = return (unsafeForeignPtrToPtr x) - marshalFree (MXAlgEl x) _ = touchForeignPtr x -foreign import ccall unsafe "&delete_casadi__MXAlgEl" - c_delete_casadi__MXAlgEl :: FunPtr (Ptr MXAlgEl' -> IO ()) -instance WrapReturn (Ptr MXAlgEl') MXAlgEl where - wrapReturn = (fmap MXAlgEl) . (newForeignPtr c_delete_casadi__MXAlgEl) - - --- raw decl data MXFunction' -- data decl {-| @@ -868,6 +1084,126 @@ -- raw decl +data Map' +-- data decl +{-| +-} +newtype Map = Map (ForeignPtr Map') +-- typeclass decl +class MapClass a where + castMap :: a -> Map +instance MapClass Map where + castMap = id + +-- baseclass instances +instance FunctionClass Map where + castFunction (Map x) = Function (castForeignPtr x) + +instance OptionsFunctionalityClass Map where + castOptionsFunctionality (Map x) = OptionsFunctionality (castForeignPtr x) + +instance SharedObjectClass Map where + castSharedObject (Map x) = SharedObject (castForeignPtr x) + +instance IOInterfaceFunctionClass Map where + castIOInterfaceFunction (Map x) = IOInterfaceFunction (castForeignPtr x) + + +-- helper instances +instance Marshal Map (Ptr Map') where + marshal (Map x) = return (unsafeForeignPtrToPtr x) + marshalFree (Map x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__Map" + c_delete_casadi__Map :: FunPtr (Ptr Map' -> IO ()) +instance WrapReturn (Ptr Map') Map where + wrapReturn = (fmap Map) . (newForeignPtr c_delete_casadi__Map) + + +-- raw decl +data MapAccum' +-- data decl +{-| +-} +newtype MapAccum = MapAccum (ForeignPtr MapAccum') +-- typeclass decl +class MapAccumClass a where + castMapAccum :: a -> MapAccum +instance MapAccumClass MapAccum where + castMapAccum = id + +-- baseclass instances +instance FunctionClass MapAccum where + castFunction (MapAccum x) = Function (castForeignPtr x) + +instance OptionsFunctionalityClass MapAccum where + castOptionsFunctionality (MapAccum x) = OptionsFunctionality (castForeignPtr x) + +instance SharedObjectClass MapAccum where + castSharedObject (MapAccum x) = SharedObject (castForeignPtr x) + +instance IOInterfaceFunctionClass MapAccum where + castIOInterfaceFunction (MapAccum x) = IOInterfaceFunction (castForeignPtr x) + + +-- helper instances +instance Marshal MapAccum (Ptr MapAccum') where + marshal (MapAccum x) = return (unsafeForeignPtrToPtr x) + marshalFree (MapAccum x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__MapAccum" + c_delete_casadi__MapAccum :: FunPtr (Ptr MapAccum' -> IO ()) +instance WrapReturn (Ptr MapAccum') MapAccum where + wrapReturn = (fmap MapAccum) . (newForeignPtr c_delete_casadi__MapAccum) + + +-- raw decl +data MatrixCommon' +-- data decl +{-| +-} +newtype MatrixCommon = MatrixCommon (ForeignPtr MatrixCommon') +-- typeclass decl +class MatrixCommonClass a where + castMatrixCommon :: a -> MatrixCommon +instance MatrixCommonClass MatrixCommon where + castMatrixCommon = id + +-- baseclass instances + +-- helper instances +instance Marshal MatrixCommon (Ptr MatrixCommon') where + marshal (MatrixCommon x) = return (unsafeForeignPtrToPtr x) + marshalFree (MatrixCommon x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__MatrixCommon" + c_delete_casadi__MatrixCommon :: FunPtr (Ptr MatrixCommon' -> IO ()) +instance WrapReturn (Ptr MatrixCommon') MatrixCommon where + wrapReturn = (fmap MatrixCommon) . (newForeignPtr c_delete_casadi__MatrixCommon) + + +-- raw decl +data NlpBuilder' +-- data decl +{-| +-} +newtype NlpBuilder = NlpBuilder (ForeignPtr NlpBuilder') +-- typeclass decl +class NlpBuilderClass a where + castNlpBuilder :: a -> NlpBuilder +instance NlpBuilderClass NlpBuilder where + castNlpBuilder = id + +-- baseclass instances + +-- helper instances +instance Marshal NlpBuilder (Ptr NlpBuilder') where + marshal (NlpBuilder x) = return (unsafeForeignPtrToPtr x) + marshalFree (NlpBuilder x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__NlpBuilder" + c_delete_casadi__NlpBuilder :: FunPtr (Ptr NlpBuilder' -> IO ()) +instance WrapReturn (Ptr NlpBuilder') NlpBuilder where + wrapReturn = (fmap NlpBuilder) . (newForeignPtr c_delete_casadi__NlpBuilder) + + +-- raw decl data NlpSolver' -- data decl {-| @@ -967,42 +1303,6 @@ -- raw decl -data Parallelizer' --- data decl -{-| --} -newtype Parallelizer = Parallelizer (ForeignPtr Parallelizer') --- typeclass decl -class ParallelizerClass a where - castParallelizer :: a -> Parallelizer -instance ParallelizerClass Parallelizer where - castParallelizer = id - --- baseclass instances -instance FunctionClass Parallelizer where - castFunction (Parallelizer x) = Function (castForeignPtr x) - -instance OptionsFunctionalityClass Parallelizer where - castOptionsFunctionality (Parallelizer x) = OptionsFunctionality (castForeignPtr x) - -instance SharedObjectClass Parallelizer where - castSharedObject (Parallelizer x) = SharedObject (castForeignPtr x) - -instance IOInterfaceFunctionClass Parallelizer where - castIOInterfaceFunction (Parallelizer x) = IOInterfaceFunction (castForeignPtr x) - - --- helper instances -instance Marshal Parallelizer (Ptr Parallelizer') where - marshal (Parallelizer x) = return (unsafeForeignPtrToPtr x) - marshalFree (Parallelizer x) _ = touchForeignPtr x -foreign import ccall unsafe "&delete_casadi__Parallelizer" - c_delete_casadi__Parallelizer :: FunPtr (Ptr Parallelizer' -> IO ()) -instance WrapReturn (Ptr Parallelizer') Parallelizer where - wrapReturn = (fmap Parallelizer) . (newForeignPtr c_delete_casadi__Parallelizer) - - --- raw decl data QcqpSolver' -- data decl {-| @@ -1087,7 +1387,19 @@ castSX = id -- baseclass instances +instance GenericExpressionCommonClass SX where + castGenericExpressionCommon (SX x) = GenericExpressionCommon (castForeignPtr x) +instance GenericMatrixCommonClass SX where + castGenericMatrixCommon (SX x) = GenericMatrixCommon (castForeignPtr x) + +instance MatrixCommonClass SX where + castMatrixCommon (SX x) = MatrixCommon (castForeignPtr x) + +instance SparsityInterfaceCommonClass SX where + castSparsityInterfaceCommon (SX x) = SparsityInterfaceCommon (castForeignPtr x) + + -- helper instances instance Marshal SX (Ptr SX') where marshal (SX x) = return (unsafeForeignPtrToPtr x) @@ -1099,6 +1411,30 @@ -- raw decl +data SXElement' +-- data decl +{-| +-} +newtype SXElement = SXElement (ForeignPtr SXElement') +-- typeclass decl +class SXElementClass a where + castSXElement :: a -> SXElement +instance SXElementClass SXElement where + castSXElement = id + +-- baseclass instances + +-- helper instances +instance Marshal SXElement (Ptr SXElement') where + marshal (SXElement x) = return (unsafeForeignPtrToPtr x) + marshalFree (SXElement x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__SXElement" + c_delete_casadi__SXElement :: FunPtr (Ptr SXElement' -> IO ()) +instance WrapReturn (Ptr SXElement') SXElement where + wrapReturn = (fmap SXElement) . (newForeignPtr c_delete_casadi__SXElement) + + +-- raw decl data SXFunction' -- data decl {-| @@ -1342,7 +1678,10 @@ instance SharedObjectClass Sparsity where castSharedObject (Sparsity x) = SharedObject (castForeignPtr x) +instance SparsityInterfaceCommonClass Sparsity where + castSparsityInterfaceCommon (Sparsity x) = SparsityInterfaceCommon (castForeignPtr x) + -- helper instances instance Marshal Sparsity (Ptr Sparsity') where marshal (Sparsity x) = return (unsafeForeignPtrToPtr x) @@ -1354,6 +1693,30 @@ -- raw decl +data SparsityInterfaceCommon' +-- data decl +{-| +-} +newtype SparsityInterfaceCommon = SparsityInterfaceCommon (ForeignPtr SparsityInterfaceCommon') +-- typeclass decl +class SparsityInterfaceCommonClass a where + castSparsityInterfaceCommon :: a -> SparsityInterfaceCommon +instance SparsityInterfaceCommonClass SparsityInterfaceCommon where + castSparsityInterfaceCommon = id + +-- baseclass instances + +-- helper instances +instance Marshal SparsityInterfaceCommon (Ptr SparsityInterfaceCommon') where + marshal (SparsityInterfaceCommon x) = return (unsafeForeignPtrToPtr x) + marshalFree (SparsityInterfaceCommon x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__SparsityInterfaceCommon" + c_delete_casadi__SparsityInterfaceCommon :: FunPtr (Ptr SparsityInterfaceCommon' -> IO ()) +instance WrapReturn (Ptr SparsityInterfaceCommon') SparsityInterfaceCommon where + wrapReturn = (fmap SparsityInterfaceCommon) . (newForeignPtr c_delete_casadi__SparsityInterfaceCommon) + + +-- raw decl data StabilizedQpSolver' -- data decl {-| @@ -1390,51 +1753,39 @@ -- raw decl -data SymbolicNLP' +data Switch' -- data decl {-| -} -newtype SymbolicNLP = SymbolicNLP (ForeignPtr SymbolicNLP') +newtype Switch = Switch (ForeignPtr Switch') -- typeclass decl -class SymbolicNLPClass a where - castSymbolicNLP :: a -> SymbolicNLP -instance SymbolicNLPClass SymbolicNLP where - castSymbolicNLP = id +class SwitchClass a where + castSwitch :: a -> Switch +instance SwitchClass Switch where + castSwitch = id -- baseclass instances +instance FunctionClass Switch where + castFunction (Switch x) = Function (castForeignPtr x) --- helper instances -instance Marshal SymbolicNLP (Ptr SymbolicNLP') where - marshal (SymbolicNLP x) = return (unsafeForeignPtrToPtr x) - marshalFree (SymbolicNLP x) _ = touchForeignPtr x -foreign import ccall unsafe "&delete_casadi__SymbolicNLP" - c_delete_casadi__SymbolicNLP :: FunPtr (Ptr SymbolicNLP' -> IO ()) -instance WrapReturn (Ptr SymbolicNLP') SymbolicNLP where - wrapReturn = (fmap SymbolicNLP) . (newForeignPtr c_delete_casadi__SymbolicNLP) +instance OptionsFunctionalityClass Switch where + castOptionsFunctionality (Switch x) = OptionsFunctionality (castForeignPtr x) +instance SharedObjectClass Switch where + castSharedObject (Switch x) = SharedObject (castForeignPtr x) --- raw decl -data SymbolicOCP' --- data decl -{-| --} -newtype SymbolicOCP = SymbolicOCP (ForeignPtr SymbolicOCP') --- typeclass decl -class SymbolicOCPClass a where - castSymbolicOCP :: a -> SymbolicOCP -instance SymbolicOCPClass SymbolicOCP where - castSymbolicOCP = id +instance IOInterfaceFunctionClass Switch where + castIOInterfaceFunction (Switch x) = IOInterfaceFunction (castForeignPtr x) --- baseclass instances -- helper instances -instance Marshal SymbolicOCP (Ptr SymbolicOCP') where - marshal (SymbolicOCP x) = return (unsafeForeignPtrToPtr x) - marshalFree (SymbolicOCP x) _ = touchForeignPtr x -foreign import ccall unsafe "&delete_casadi__SymbolicOCP" - c_delete_casadi__SymbolicOCP :: FunPtr (Ptr SymbolicOCP' -> IO ()) -instance WrapReturn (Ptr SymbolicOCP') SymbolicOCP where - wrapReturn = (fmap SymbolicOCP) . (newForeignPtr c_delete_casadi__SymbolicOCP) +instance Marshal Switch (Ptr Switch') where + marshal (Switch x) = return (unsafeForeignPtrToPtr x) + marshalFree (Switch x) _ = touchForeignPtr x +foreign import ccall unsafe "&delete_casadi__Switch" + c_delete_casadi__Switch :: FunPtr (Ptr Switch' -> IO ()) +instance WrapReturn (Ptr Switch') Switch where + wrapReturn = (fmap Switch) . (newForeignPtr c_delete_casadi__Switch) -- raw decl diff --git a/Casadi/Core/Enums.hs b/Casadi/Core/Enums.hs --- a/Casadi/Core/Enums.hs +++ b/Casadi/Core/Enums.hs @@ -5,2121 +5,605 @@ module Casadi.Core.Enums ( Alias(..), - CLEInput(..), - CLEOutput(..), - Category(..), - Causality(..), - CleStruct(..), - CollocationPoints(..), - ControlSimulatorInput(..), - ControlledDAEInput(..), - DAEInput(..), - DAEOutput(..), - DLEInput(..), - DLEOutput(..), - DPLEInput(..), - DPLEOutput(..), - DleStruct(..), - DpleVecStruct(..), - Dynamics(..), - GradFInput(..), - GradFOutput(..), - HNLPInput(..), - HessLagInput(..), - HessLagOutput(..), - InputOutputScheme(..), - IntegratorInput(..), - IntegratorOutput(..), - JacGInput(..), - JacGOutput(..), - LPStruct(..), - LR_DLEInput(..), - LR_DLEOutput(..), - LR_DPLEInput(..), - LR_DPLEOutput(..), - LinsolInput(..), - LinsolOutput(..), - LpSolverInput(..), - LpSolverOutput(..), - LrDleStruct(..), - LrDpleVecStruct(..), - NLPInput(..), - NLPOutput(..), - NlpSolverInput(..), - NlpSolverOutput(..), - Operation(..), - Opt_type(..), - QCQPStruct(..), - QPStruct(..), - QcqpSolverInput(..), - QcqpSolverOutput(..), - QpSolverInput(..), - QpSolverOutput(..), - RDAEInput(..), - RDAEOutput(..), - SDPInput(..), - SDPOutput(..), - SDPStruct(..), - SDQPInput(..), - SDQPOutput(..), - SDQPStruct(..), - SOCPInput(..), - SOCPOutput(..), - SOCPStruct(..), - SparsityType(..), - StabilizedQpSolverInput(..), - Variability(..), - ) where - - -import Foreign.C.Types ( CInt(..) ) -import Casadi.Internal.Marshal ( Marshal(..) ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) - --- EnumDecl: Alias -data Alias = ALIAS - | NEGATED_ALIAS - | NO_ALIAS - deriving (Show, Eq) -instance Enum Alias where - fromEnum (ALIAS) = 1 - fromEnum (NEGATED_ALIAS) = 2 - fromEnum (NO_ALIAS) = 0 - toEnum (1) = ALIAS - toEnum (2) = NEGATED_ALIAS - toEnum (0) = NO_ALIAS - toEnum k - = error $ "Alias: toEnum: got unhandled number: " ++ show k -instance Marshal Alias CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt Alias where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: CLEInput -data CLEInput = CLE_A - | CLE_NUM_IN - | CLE_V - deriving (Show, Eq) -instance Enum CLEInput where - fromEnum (CLE_A) = 0 - fromEnum (CLE_NUM_IN) = 2 - fromEnum (CLE_V) = 1 - toEnum (0) = CLE_A - toEnum (2) = CLE_NUM_IN - toEnum (1) = CLE_V - toEnum k - = error $ "CLEInput: toEnum: got unhandled number: " ++ show k -instance Marshal CLEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt CLEInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: CLEOutput -data CLEOutput = CLE_NUM_OUT - | CLE_P - deriving (Show, Eq) -instance Enum CLEOutput where - fromEnum (CLE_NUM_OUT) = 1 - fromEnum (CLE_P) = 0 - toEnum (1) = CLE_NUM_OUT - toEnum (0) = CLE_P - toEnum k - = error $ "CLEOutput: toEnum: got unhandled number: " ++ show k -instance Marshal CLEOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt CLEOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: Category -data Category = CAT_ALGEBRAIC - | CAT_DEPENDENT_CONSTANT - | CAT_DEPENDENT_PARAMETER - | CAT_DERIVATIVE - | CAT_INDEPENDENT_CONSTANT - | CAT_INDEPENDENT_PARAMETER - | CAT_STATE - | CAT_UNKNOWN - deriving (Show, Eq) -instance Enum Category where - fromEnum (CAT_ALGEBRAIC) = 7 - fromEnum (CAT_DEPENDENT_CONSTANT) = 3 - fromEnum (CAT_DEPENDENT_PARAMETER) = 5 - fromEnum (CAT_DERIVATIVE) = 1 - fromEnum (CAT_INDEPENDENT_CONSTANT) = 4 - fromEnum (CAT_INDEPENDENT_PARAMETER) = 6 - fromEnum (CAT_STATE) = 2 - fromEnum (CAT_UNKNOWN) = 0 - toEnum (7) = CAT_ALGEBRAIC - toEnum (3) = CAT_DEPENDENT_CONSTANT - toEnum (5) = CAT_DEPENDENT_PARAMETER - toEnum (1) = CAT_DERIVATIVE - toEnum (4) = CAT_INDEPENDENT_CONSTANT - toEnum (6) = CAT_INDEPENDENT_PARAMETER - toEnum (2) = CAT_STATE - toEnum (0) = CAT_UNKNOWN - toEnum k - = error $ "Category: toEnum: got unhandled number: " ++ show k -instance Marshal Category CInt where - marshal = return . fromIntegral . fromEnum -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 - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt Causality where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: CleStruct -data CleStruct = Cle_STRUCT_A - | Cle_STRUCT_C - | Cle_STRUCT_NUM - | Cle_STRUCT_V - deriving (Show, Eq) -instance Enum CleStruct where - fromEnum (Cle_STRUCT_A) = 0 - fromEnum (Cle_STRUCT_C) = 2 - fromEnum (Cle_STRUCT_NUM) = 3 - fromEnum (Cle_STRUCT_V) = 1 - toEnum (0) = Cle_STRUCT_A - toEnum (2) = Cle_STRUCT_C - toEnum (3) = Cle_STRUCT_NUM - toEnum (1) = Cle_STRUCT_V - toEnum k - = error $ "CleStruct: toEnum: got unhandled number: " ++ show k -instance Marshal CleStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt CleStruct 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 - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt CollocationPoints where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: ControlSimulatorInput -data ControlSimulatorInput = CONTROLSIMULATOR_NUM_IN - | CONTROLSIMULATOR_P - | CONTROLSIMULATOR_U - | CONTROLSIMULATOR_X0 - deriving (Show, Eq) -instance Enum ControlSimulatorInput where - fromEnum (CONTROLSIMULATOR_NUM_IN) = 3 - fromEnum (CONTROLSIMULATOR_P) = 1 - fromEnum (CONTROLSIMULATOR_U) = 2 - fromEnum (CONTROLSIMULATOR_X0) = 0 - toEnum (3) = CONTROLSIMULATOR_NUM_IN - toEnum (1) = CONTROLSIMULATOR_P - toEnum (2) = CONTROLSIMULATOR_U - toEnum (0) = CONTROLSIMULATOR_X0 - toEnum k - = error $ "ControlSimulatorInput: toEnum: got unhandled number: " - ++ show k -instance Marshal ControlSimulatorInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt ControlSimulatorInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: ControlledDAEInput -data ControlledDAEInput = CONTROL_DAE_NUM_IN - | CONTROL_DAE_P - | CONTROL_DAE_T - | CONTROL_DAE_T0 - | CONTROL_DAE_TF - | CONTROL_DAE_U - | CONTROL_DAE_U_INTERP - | CONTROL_DAE_X - | CONTROL_DAE_X_MAJOR - | CONTROL_DAE_Z - deriving (Show, Eq) -instance Enum ControlledDAEInput where - fromEnum (CONTROL_DAE_NUM_IN) = 9 - fromEnum (CONTROL_DAE_P) = 3 - fromEnum (CONTROL_DAE_T) = 0 - fromEnum (CONTROL_DAE_T0) = 7 - fromEnum (CONTROL_DAE_TF) = 8 - fromEnum (CONTROL_DAE_U) = 4 - fromEnum (CONTROL_DAE_U_INTERP) = 5 - fromEnum (CONTROL_DAE_X) = 1 - fromEnum (CONTROL_DAE_X_MAJOR) = 6 - fromEnum (CONTROL_DAE_Z) = 2 - toEnum (9) = CONTROL_DAE_NUM_IN - toEnum (3) = CONTROL_DAE_P - toEnum (0) = CONTROL_DAE_T - toEnum (7) = CONTROL_DAE_T0 - toEnum (8) = CONTROL_DAE_TF - toEnum (4) = CONTROL_DAE_U - toEnum (5) = CONTROL_DAE_U_INTERP - toEnum (1) = CONTROL_DAE_X - toEnum (6) = CONTROL_DAE_X_MAJOR - toEnum (2) = CONTROL_DAE_Z - toEnum k - = error $ "ControlledDAEInput: toEnum: got unhandled number: " ++ - show k -instance Marshal ControlledDAEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt ControlledDAEInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: DAEInput -data DAEInput = DAE_NUM_IN - | DAE_P - | DAE_T - | DAE_X - | DAE_Z - deriving (Show, Eq) -instance Enum DAEInput where - fromEnum (DAE_NUM_IN) = 4 - fromEnum (DAE_P) = 2 - fromEnum (DAE_T) = 3 - fromEnum (DAE_X) = 0 - fromEnum (DAE_Z) = 1 - toEnum (4) = DAE_NUM_IN - toEnum (2) = DAE_P - toEnum (3) = DAE_T - toEnum (0) = DAE_X - toEnum (1) = DAE_Z - toEnum k - = error $ "DAEInput: toEnum: got unhandled number: " ++ show k -instance Marshal DAEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DAEInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: DAEOutput -data DAEOutput = DAE_ALG - | DAE_NUM_OUT - | DAE_ODE - | DAE_QUAD - deriving (Show, Eq) -instance Enum DAEOutput where - fromEnum (DAE_ALG) = 1 - fromEnum (DAE_NUM_OUT) = 3 - fromEnum (DAE_ODE) = 0 - fromEnum (DAE_QUAD) = 2 - toEnum (1) = DAE_ALG - toEnum (3) = DAE_NUM_OUT - toEnum (0) = DAE_ODE - toEnum (2) = DAE_QUAD - toEnum k - = error $ "DAEOutput: toEnum: got unhandled number: " ++ show k -instance Marshal DAEOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DAEOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: DLEInput -data DLEInput = DLE_A - | DLE_NUM_IN - | DLE_V - deriving (Show, Eq) -instance Enum DLEInput where - fromEnum (DLE_A) = 0 - fromEnum (DLE_NUM_IN) = 2 - fromEnum (DLE_V) = 1 - toEnum (0) = DLE_A - toEnum (2) = DLE_NUM_IN - toEnum (1) = DLE_V - toEnum k - = error $ "DLEInput: toEnum: got unhandled number: " ++ show k -instance Marshal DLEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DLEInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: DLEOutput -data DLEOutput = DLE_NUM_OUT - | DLE_P - deriving (Show, Eq) -instance Enum DLEOutput where - fromEnum (DLE_NUM_OUT) = 1 - fromEnum (DLE_P) = 0 - toEnum (1) = DLE_NUM_OUT - toEnum (0) = DLE_P - toEnum k - = error $ "DLEOutput: toEnum: got unhandled number: " ++ show k -instance Marshal DLEOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DLEOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: DPLEInput -data DPLEInput = DPLE_A - | DPLE_NUM_IN - | DPLE_V - deriving (Show, Eq) -instance Enum DPLEInput where - fromEnum (DPLE_A) = 0 - fromEnum (DPLE_NUM_IN) = 2 - fromEnum (DPLE_V) = 1 - toEnum (0) = DPLE_A - toEnum (2) = DPLE_NUM_IN - toEnum (1) = DPLE_V - toEnum k - = error $ "DPLEInput: toEnum: got unhandled number: " ++ show k -instance Marshal DPLEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DPLEInput 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 - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DPLEOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: DleStruct -data DleStruct = Dle_STRUCT_A - | Dle_STRUCT_NUM - | Dle_STRUCT_V - deriving (Show, Eq) -instance Enum DleStruct where - fromEnum (Dle_STRUCT_A) = 0 - fromEnum (Dle_STRUCT_NUM) = 2 - fromEnum (Dle_STRUCT_V) = 1 - toEnum (0) = Dle_STRUCT_A - toEnum (2) = Dle_STRUCT_NUM - toEnum (1) = Dle_STRUCT_V - toEnum k - = error $ "DleStruct: toEnum: got unhandled number: " ++ show k -instance Marshal DleStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DleStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: DpleVecStruct -data DpleVecStruct = Dple_STRUCT_A - | Dple_STRUCT_NUM - | Dple_STRUCT_V - deriving (Show, Eq) -instance Enum DpleVecStruct where - fromEnum (Dple_STRUCT_A) = 0 - fromEnum (Dple_STRUCT_NUM) = 2 - fromEnum (Dple_STRUCT_V) = 1 - toEnum (0) = Dple_STRUCT_A - toEnum (2) = Dple_STRUCT_NUM - toEnum (1) = Dple_STRUCT_V - toEnum k - = error $ "DpleVecStruct: toEnum: got unhandled number: " ++ show k -instance Marshal DpleVecStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt DpleVecStruct 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 - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt Dynamics where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: GradFInput -data GradFInput = GRADF_NUM_IN - | GRADF_P - | GRADF_X - deriving (Show, Eq) -instance Enum GradFInput where - fromEnum (GRADF_NUM_IN) = 2 - fromEnum (GRADF_P) = 1 - fromEnum (GRADF_X) = 0 - toEnum (2) = GRADF_NUM_IN - toEnum (1) = GRADF_P - toEnum (0) = GRADF_X - toEnum k - = error $ "GradFInput: toEnum: got unhandled number: " ++ show k -instance Marshal GradFInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt GradFInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: GradFOutput -data GradFOutput = GRADF_F - | GRADF_G - | GRADF_GRAD - | GRADF_NUM_OUT - deriving (Show, Eq) -instance Enum GradFOutput where - fromEnum (GRADF_F) = 1 - fromEnum (GRADF_G) = 2 - fromEnum (GRADF_GRAD) = 0 - fromEnum (GRADF_NUM_OUT) = 3 - toEnum (1) = GRADF_F - toEnum (2) = GRADF_G - toEnum (0) = GRADF_GRAD - toEnum (3) = GRADF_NUM_OUT - toEnum k - = error $ "GradFOutput: toEnum: got unhandled number: " ++ show k -instance Marshal GradFOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt GradFOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: HNLPInput -data HNLPInput = HNL_NUM_IN - | HNL_P - | HNL_TAU - | HNL_X - deriving (Show, Eq) -instance Enum HNLPInput where - fromEnum (HNL_NUM_IN) = 3 - fromEnum (HNL_P) = 1 - fromEnum (HNL_TAU) = 2 - fromEnum (HNL_X) = 0 - toEnum (3) = HNL_NUM_IN - toEnum (1) = HNL_P - toEnum (2) = HNL_TAU - toEnum (0) = HNL_X - toEnum k - = error $ "HNLPInput: toEnum: got unhandled number: " ++ show k -instance Marshal HNLPInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt HNLPInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: HessLagInput -data HessLagInput = HESSLAG_LAM_F - | HESSLAG_LAM_G - | HESSLAG_NUM_IN - | HESSLAG_P - | HESSLAG_X - deriving (Show, Eq) -instance Enum HessLagInput where - fromEnum (HESSLAG_LAM_F) = 2 - fromEnum (HESSLAG_LAM_G) = 3 - fromEnum (HESSLAG_NUM_IN) = 4 - fromEnum (HESSLAG_P) = 1 - fromEnum (HESSLAG_X) = 0 - toEnum (2) = HESSLAG_LAM_F - toEnum (3) = HESSLAG_LAM_G - toEnum (4) = HESSLAG_NUM_IN - toEnum (1) = HESSLAG_P - toEnum (0) = HESSLAG_X - toEnum k - = error $ "HessLagInput: toEnum: got unhandled number: " ++ show k -instance Marshal HessLagInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt HessLagInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: HessLagOutput -data HessLagOutput = HESSLAG_F - | HESSLAG_G - | HESSLAG_GRAD_P - | HESSLAG_GRAD_X - | HESSLAG_HESS - | HESSLAG_NUM_OUT - deriving (Show, Eq) -instance Enum HessLagOutput where - fromEnum (HESSLAG_F) = 1 - fromEnum (HESSLAG_G) = 2 - fromEnum (HESSLAG_GRAD_P) = 4 - fromEnum (HESSLAG_GRAD_X) = 3 - fromEnum (HESSLAG_HESS) = 0 - fromEnum (HESSLAG_NUM_OUT) = 5 - toEnum (1) = HESSLAG_F - toEnum (2) = HESSLAG_G - toEnum (4) = HESSLAG_GRAD_P - toEnum (3) = HESSLAG_GRAD_X - toEnum (0) = HESSLAG_HESS - toEnum (5) = HESSLAG_NUM_OUT - toEnum k - = error $ "HessLagOutput: toEnum: got unhandled number: " ++ show k -instance Marshal HessLagOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt HessLagOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: InputOutputScheme -data InputOutputScheme = SCHEME_CLEInput - | SCHEME_CLEOutput - | SCHEME_CleStruct - | SCHEME_ControlSimulatorInput - | SCHEME_ControlledDAEInput - | SCHEME_DAEInput - | SCHEME_DAEOutput - | SCHEME_DLEInput - | SCHEME_DLEOutput - | SCHEME_DPLEInput - | SCHEME_DPLEOutput - | SCHEME_DleStruct - | SCHEME_DpleVecStruct - | SCHEME_GradFInput - | SCHEME_GradFOutput - | SCHEME_HNLPInput - | SCHEME_HessLagInput - | SCHEME_HessLagOutput - | SCHEME_IntegratorInput - | SCHEME_IntegratorOutput - | SCHEME_JacGInput - | SCHEME_JacGOutput - | SCHEME_LPStruct - | SCHEME_LR_DLEInput - | SCHEME_LR_DLEOutput - | SCHEME_LR_DPLEInput - | SCHEME_LR_DPLEOutput - | SCHEME_LinsolInput - | SCHEME_LinsolOutput - | SCHEME_LpSolverInput - | SCHEME_LpSolverOutput - | SCHEME_LrDleStruct - | SCHEME_LrDpleVecStruct - | SCHEME_NLPInput - | SCHEME_NLPOutput - | SCHEME_NlpSolverInput - | SCHEME_NlpSolverOutput - | SCHEME_QCQPStruct - | SCHEME_QPStruct - | SCHEME_QcqpSolverInput - | SCHEME_QcqpSolverOutput - | SCHEME_QpSolverInput - | SCHEME_QpSolverOutput - | SCHEME_RDAEInput - | SCHEME_RDAEOutput - | SCHEME_SDPInput - | SCHEME_SDPOutput - | SCHEME_SDPStruct - | SCHEME_SDQPInput - | SCHEME_SDQPOutput - | SCHEME_SDQPStruct - | SCHEME_SOCPInput - | SCHEME_SOCPOutput - | SCHEME_SOCPStruct - | SCHEME_StabilizedQpSolverInput - deriving (Show, Eq) -instance Enum InputOutputScheme where - fromEnum (SCHEME_CLEInput) = 0 - fromEnum (SCHEME_CLEOutput) = 1 - fromEnum (SCHEME_CleStruct) = 2 - fromEnum (SCHEME_ControlSimulatorInput) = 4 - fromEnum (SCHEME_ControlledDAEInput) = 3 - fromEnum (SCHEME_DAEInput) = 12 - fromEnum (SCHEME_DAEOutput) = 13 - fromEnum (SCHEME_DLEInput) = 5 - fromEnum (SCHEME_DLEOutput) = 6 - fromEnum (SCHEME_DPLEInput) = 8 - fromEnum (SCHEME_DPLEOutput) = 9 - fromEnum (SCHEME_DleStruct) = 7 - fromEnum (SCHEME_DpleVecStruct) = 10 - fromEnum (SCHEME_GradFInput) = 31 - fromEnum (SCHEME_GradFOutput) = 32 - fromEnum (SCHEME_HNLPInput) = 11 - fromEnum (SCHEME_HessLagInput) = 35 - fromEnum (SCHEME_HessLagOutput) = 36 - fromEnum (SCHEME_IntegratorInput) = 16 - fromEnum (SCHEME_IntegratorOutput) = 17 - fromEnum (SCHEME_JacGInput) = 33 - fromEnum (SCHEME_JacGOutput) = 34 - fromEnum (SCHEME_LPStruct) = 22 - fromEnum (SCHEME_LR_DLEInput) = 23 - fromEnum (SCHEME_LR_DLEOutput) = 24 - fromEnum (SCHEME_LR_DPLEInput) = 26 - fromEnum (SCHEME_LR_DPLEOutput) = 27 - fromEnum (SCHEME_LinsolInput) = 18 - fromEnum (SCHEME_LinsolOutput) = 19 - fromEnum (SCHEME_LpSolverInput) = 20 - fromEnum (SCHEME_LpSolverOutput) = 21 - fromEnum (SCHEME_LrDleStruct) = 25 - fromEnum (SCHEME_LrDpleVecStruct) = 28 - fromEnum (SCHEME_NLPInput) = 29 - fromEnum (SCHEME_NLPOutput) = 30 - fromEnum (SCHEME_NlpSolverInput) = 37 - fromEnum (SCHEME_NlpSolverOutput) = 38 - fromEnum (SCHEME_QCQPStruct) = 41 - fromEnum (SCHEME_QPStruct) = 44 - fromEnum (SCHEME_QcqpSolverInput) = 39 - fromEnum (SCHEME_QcqpSolverOutput) = 40 - fromEnum (SCHEME_QpSolverInput) = 42 - fromEnum (SCHEME_QpSolverOutput) = 43 - fromEnum (SCHEME_RDAEInput) = 14 - fromEnum (SCHEME_RDAEOutput) = 15 - fromEnum (SCHEME_SDPInput) = 45 - fromEnum (SCHEME_SDPOutput) = 46 - fromEnum (SCHEME_SDPStruct) = 47 - fromEnum (SCHEME_SDQPInput) = 48 - fromEnum (SCHEME_SDQPOutput) = 49 - fromEnum (SCHEME_SDQPStruct) = 50 - fromEnum (SCHEME_SOCPInput) = 51 - fromEnum (SCHEME_SOCPOutput) = 52 - fromEnum (SCHEME_SOCPStruct) = 53 - fromEnum (SCHEME_StabilizedQpSolverInput) = 54 - toEnum (0) = SCHEME_CLEInput - toEnum (1) = SCHEME_CLEOutput - toEnum (2) = SCHEME_CleStruct - toEnum (4) = SCHEME_ControlSimulatorInput - toEnum (3) = SCHEME_ControlledDAEInput - toEnum (12) = SCHEME_DAEInput - toEnum (13) = SCHEME_DAEOutput - toEnum (5) = SCHEME_DLEInput - toEnum (6) = SCHEME_DLEOutput - toEnum (8) = SCHEME_DPLEInput - toEnum (9) = SCHEME_DPLEOutput - toEnum (7) = SCHEME_DleStruct - toEnum (10) = SCHEME_DpleVecStruct - toEnum (31) = SCHEME_GradFInput - toEnum (32) = SCHEME_GradFOutput - toEnum (11) = SCHEME_HNLPInput - toEnum (35) = SCHEME_HessLagInput - toEnum (36) = SCHEME_HessLagOutput - toEnum (16) = SCHEME_IntegratorInput - toEnum (17) = SCHEME_IntegratorOutput - toEnum (33) = SCHEME_JacGInput - toEnum (34) = SCHEME_JacGOutput - toEnum (22) = SCHEME_LPStruct - toEnum (23) = SCHEME_LR_DLEInput - toEnum (24) = SCHEME_LR_DLEOutput - toEnum (26) = SCHEME_LR_DPLEInput - toEnum (27) = SCHEME_LR_DPLEOutput - toEnum (18) = SCHEME_LinsolInput - toEnum (19) = SCHEME_LinsolOutput - toEnum (20) = SCHEME_LpSolverInput - toEnum (21) = SCHEME_LpSolverOutput - toEnum (25) = SCHEME_LrDleStruct - toEnum (28) = SCHEME_LrDpleVecStruct - toEnum (29) = SCHEME_NLPInput - toEnum (30) = SCHEME_NLPOutput - toEnum (37) = SCHEME_NlpSolverInput - toEnum (38) = SCHEME_NlpSolverOutput - toEnum (41) = SCHEME_QCQPStruct - toEnum (44) = SCHEME_QPStruct - toEnum (39) = SCHEME_QcqpSolverInput - toEnum (40) = SCHEME_QcqpSolverOutput - toEnum (42) = SCHEME_QpSolverInput - toEnum (43) = SCHEME_QpSolverOutput - toEnum (14) = SCHEME_RDAEInput - toEnum (15) = SCHEME_RDAEOutput - toEnum (45) = SCHEME_SDPInput - toEnum (46) = SCHEME_SDPOutput - toEnum (47) = SCHEME_SDPStruct - toEnum (48) = SCHEME_SDQPInput - toEnum (49) = SCHEME_SDQPOutput - toEnum (50) = SCHEME_SDQPStruct - toEnum (51) = SCHEME_SOCPInput - toEnum (52) = SCHEME_SOCPOutput - toEnum (53) = SCHEME_SOCPStruct - toEnum (54) = SCHEME_StabilizedQpSolverInput - toEnum k - = error $ "InputOutputScheme: toEnum: got unhandled number: " ++ - show k -instance Marshal InputOutputScheme CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt InputOutputScheme where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: IntegratorInput -data IntegratorInput = INTEGRATOR_NUM_IN - | INTEGRATOR_P - | INTEGRATOR_RP - | INTEGRATOR_RX0 - | INTEGRATOR_RZ0 - | INTEGRATOR_X0 - | INTEGRATOR_Z0 - deriving (Show, Eq) -instance Enum IntegratorInput where - fromEnum (INTEGRATOR_NUM_IN) = 6 - fromEnum (INTEGRATOR_P) = 1 - fromEnum (INTEGRATOR_RP) = 4 - fromEnum (INTEGRATOR_RX0) = 3 - fromEnum (INTEGRATOR_RZ0) = 5 - fromEnum (INTEGRATOR_X0) = 0 - fromEnum (INTEGRATOR_Z0) = 2 - toEnum (6) = INTEGRATOR_NUM_IN - toEnum (1) = INTEGRATOR_P - toEnum (4) = INTEGRATOR_RP - toEnum (3) = INTEGRATOR_RX0 - toEnum (5) = INTEGRATOR_RZ0 - toEnum (0) = INTEGRATOR_X0 - toEnum (2) = INTEGRATOR_Z0 - toEnum k - = error $ "IntegratorInput: toEnum: got unhandled number: " ++ - show k -instance Marshal IntegratorInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt IntegratorInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: IntegratorOutput -data IntegratorOutput = INTEGRATOR_NUM_OUT - | INTEGRATOR_QF - | INTEGRATOR_RQF - | INTEGRATOR_RXF - | INTEGRATOR_RZF - | INTEGRATOR_XF - | INTEGRATOR_ZF - deriving (Show, Eq) -instance Enum IntegratorOutput where - fromEnum (INTEGRATOR_NUM_OUT) = 6 - fromEnum (INTEGRATOR_QF) = 1 - fromEnum (INTEGRATOR_RQF) = 4 - fromEnum (INTEGRATOR_RXF) = 3 - fromEnum (INTEGRATOR_RZF) = 5 - fromEnum (INTEGRATOR_XF) = 0 - fromEnum (INTEGRATOR_ZF) = 2 - toEnum (6) = INTEGRATOR_NUM_OUT - toEnum (1) = INTEGRATOR_QF - toEnum (4) = INTEGRATOR_RQF - toEnum (3) = INTEGRATOR_RXF - toEnum (5) = INTEGRATOR_RZF - toEnum (0) = INTEGRATOR_XF - toEnum (2) = INTEGRATOR_ZF - toEnum k - = error $ "IntegratorOutput: toEnum: got unhandled number: " ++ - show k -instance Marshal IntegratorOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt IntegratorOutput 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 - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt JacGInput 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 - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt JacGOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LPStruct -data LPStruct = LP_STRUCT_A - | LP_STRUCT_NUM - deriving (Show, Eq) -instance Enum LPStruct where - fromEnum (LP_STRUCT_A) = 0 - fromEnum (LP_STRUCT_NUM) = 1 - toEnum (0) = LP_STRUCT_A - toEnum (1) = LP_STRUCT_NUM - toEnum k - = error $ "LPStruct: toEnum: got unhandled number: " ++ show k -instance Marshal LPStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LPStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LR_DLEInput -data LR_DLEInput = LR_DLE_A - | LR_DLE_C - | LR_DLE_H - | LR_DLE_NUM_IN - | LR_DLE_V - deriving (Show, Eq) -instance Enum LR_DLEInput where - fromEnum (LR_DLE_A) = 0 - fromEnum (LR_DLE_C) = 2 - fromEnum (LR_DLE_H) = 3 - fromEnum (LR_DLE_NUM_IN) = 4 - fromEnum (LR_DLE_V) = 1 - toEnum (0) = LR_DLE_A - toEnum (2) = LR_DLE_C - toEnum (3) = LR_DLE_H - toEnum (4) = LR_DLE_NUM_IN - toEnum (1) = LR_DLE_V - toEnum k - = error $ "LR_DLEInput: toEnum: got unhandled number: " ++ show k -instance Marshal LR_DLEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LR_DLEInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LR_DLEOutput -data LR_DLEOutput = LR_DLE_NUM_OUT - | LR_DLE_Y - deriving (Show, Eq) -instance Enum LR_DLEOutput where - fromEnum (LR_DLE_NUM_OUT) = 1 - fromEnum (LR_DLE_Y) = 0 - toEnum (1) = LR_DLE_NUM_OUT - toEnum (0) = LR_DLE_Y - toEnum k - = error $ "LR_DLEOutput: toEnum: got unhandled number: " ++ show k -instance Marshal LR_DLEOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LR_DLEOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LR_DPLEInput -data LR_DPLEInput = LR_DPLE_A - | LR_DPLE_C - | LR_DPLE_H - | LR_DPLE_NUM_IN - | LR_DPLE_V - deriving (Show, Eq) -instance Enum LR_DPLEInput where - fromEnum (LR_DPLE_A) = 0 - fromEnum (LR_DPLE_C) = 2 - fromEnum (LR_DPLE_H) = 3 - fromEnum (LR_DPLE_NUM_IN) = 4 - fromEnum (LR_DPLE_V) = 1 - toEnum (0) = LR_DPLE_A - toEnum (2) = LR_DPLE_C - toEnum (3) = LR_DPLE_H - toEnum (4) = LR_DPLE_NUM_IN - toEnum (1) = LR_DPLE_V - toEnum k - = error $ "LR_DPLEInput: toEnum: got unhandled number: " ++ show k -instance Marshal LR_DPLEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LR_DPLEInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LR_DPLEOutput -data LR_DPLEOutput = LR_DPLE_NUM_OUT - | LR_DPLE_Y - deriving (Show, Eq) -instance Enum LR_DPLEOutput where - fromEnum (LR_DPLE_NUM_OUT) = 1 - fromEnum (LR_DPLE_Y) = 0 - toEnum (1) = LR_DPLE_NUM_OUT - toEnum (0) = LR_DPLE_Y - toEnum k - = error $ "LR_DPLEOutput: toEnum: got unhandled number: " ++ show k -instance Marshal LR_DPLEOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LR_DPLEOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LinsolInput -data LinsolInput = LINSOL_A - | LINSOL_B - | LINSOL_NUM_IN - deriving (Show, Eq) -instance Enum LinsolInput where - fromEnum (LINSOL_A) = 0 - fromEnum (LINSOL_B) = 1 - fromEnum (LINSOL_NUM_IN) = 2 - toEnum (0) = LINSOL_A - toEnum (1) = LINSOL_B - toEnum (2) = LINSOL_NUM_IN - toEnum k - = error $ "LinsolInput: toEnum: got unhandled number: " ++ show k -instance Marshal LinsolInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LinsolInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LinsolOutput -data LinsolOutput = LINSOL_NUM_OUT - | LINSOL_X - deriving (Show, Eq) -instance Enum LinsolOutput where - fromEnum (LINSOL_NUM_OUT) = 1 - fromEnum (LINSOL_X) = 0 - toEnum (1) = LINSOL_NUM_OUT - toEnum (0) = LINSOL_X - toEnum k - = error $ "LinsolOutput: toEnum: got unhandled number: " ++ show k -instance Marshal LinsolOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LinsolOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LpSolverInput -data LpSolverInput = LP_SOLVER_A - | LP_SOLVER_C - | LP_SOLVER_LBA - | LP_SOLVER_LBX - | LP_SOLVER_NUM_IN - | LP_SOLVER_UBA - | LP_SOLVER_UBX - deriving (Show, Eq) -instance Enum LpSolverInput where - fromEnum (LP_SOLVER_A) = 1 - fromEnum (LP_SOLVER_C) = 0 - fromEnum (LP_SOLVER_LBA) = 2 - fromEnum (LP_SOLVER_LBX) = 4 - fromEnum (LP_SOLVER_NUM_IN) = 6 - fromEnum (LP_SOLVER_UBA) = 3 - fromEnum (LP_SOLVER_UBX) = 5 - toEnum (1) = LP_SOLVER_A - toEnum (0) = LP_SOLVER_C - toEnum (2) = LP_SOLVER_LBA - toEnum (4) = LP_SOLVER_LBX - toEnum (6) = LP_SOLVER_NUM_IN - toEnum (3) = LP_SOLVER_UBA - toEnum (5) = LP_SOLVER_UBX - toEnum k - = error $ "LpSolverInput: toEnum: got unhandled number: " ++ show k -instance Marshal LpSolverInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LpSolverInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LpSolverOutput -data LpSolverOutput = LP_SOLVER_COST - | LP_SOLVER_LAM_A - | LP_SOLVER_LAM_X - | LP_SOLVER_NUM_OUT - | LP_SOLVER_X - deriving (Show, Eq) -instance Enum LpSolverOutput where - fromEnum (LP_SOLVER_COST) = 1 - fromEnum (LP_SOLVER_LAM_A) = 2 - fromEnum (LP_SOLVER_LAM_X) = 3 - fromEnum (LP_SOLVER_NUM_OUT) = 4 - fromEnum (LP_SOLVER_X) = 0 - toEnum (1) = LP_SOLVER_COST - toEnum (2) = LP_SOLVER_LAM_A - toEnum (3) = LP_SOLVER_LAM_X - toEnum (4) = LP_SOLVER_NUM_OUT - toEnum (0) = LP_SOLVER_X - toEnum k - = error $ "LpSolverOutput: toEnum: got unhandled number: " ++ - show k -instance Marshal LpSolverOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LpSolverOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LrDleStruct -data LrDleStruct = LR_DLE_STRUCT_A - | LR_DLE_STRUCT_C - | LR_DLE_STRUCT_H - | LR_DLE_STRUCT_NUM - | LR_DLE_STRUCT_V - deriving (Show, Eq) -instance Enum LrDleStruct where - fromEnum (LR_DLE_STRUCT_A) = 0 - fromEnum (LR_DLE_STRUCT_C) = 2 - fromEnum (LR_DLE_STRUCT_H) = 3 - fromEnum (LR_DLE_STRUCT_NUM) = 4 - fromEnum (LR_DLE_STRUCT_V) = 1 - toEnum (0) = LR_DLE_STRUCT_A - toEnum (2) = LR_DLE_STRUCT_C - toEnum (3) = LR_DLE_STRUCT_H - toEnum (4) = LR_DLE_STRUCT_NUM - toEnum (1) = LR_DLE_STRUCT_V - toEnum k - = error $ "LrDleStruct: toEnum: got unhandled number: " ++ show k -instance Marshal LrDleStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LrDleStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: LrDpleVecStruct -data LrDpleVecStruct = LR_Dple_STRUCT_A - | LR_Dple_STRUCT_C - | LR_Dple_STRUCT_H - | LR_Dple_STRUCT_NUM - | LR_Dple_STRUCT_V - deriving (Show, Eq) -instance Enum LrDpleVecStruct where - fromEnum (LR_Dple_STRUCT_A) = 0 - fromEnum (LR_Dple_STRUCT_C) = 2 - fromEnum (LR_Dple_STRUCT_H) = 3 - fromEnum (LR_Dple_STRUCT_NUM) = 4 - fromEnum (LR_Dple_STRUCT_V) = 1 - toEnum (0) = LR_Dple_STRUCT_A - toEnum (2) = LR_Dple_STRUCT_C - toEnum (3) = LR_Dple_STRUCT_H - toEnum (4) = LR_Dple_STRUCT_NUM - toEnum (1) = LR_Dple_STRUCT_V - toEnum k - = error $ "LrDpleVecStruct: toEnum: got unhandled number: " ++ - show k -instance Marshal LrDpleVecStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt LrDpleVecStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: NLPInput -data NLPInput = NL_NUM_IN - | NL_P - | NL_X - deriving (Show, Eq) -instance Enum NLPInput where - fromEnum (NL_NUM_IN) = 2 - fromEnum (NL_P) = 1 - fromEnum (NL_X) = 0 - toEnum (2) = NL_NUM_IN - toEnum (1) = NL_P - toEnum (0) = NL_X - toEnum k - = error $ "NLPInput: toEnum: got unhandled number: " ++ show k -instance Marshal NLPInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt NLPInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: NLPOutput -data NLPOutput = NL_F - | NL_G - | NL_NUM_OUT - deriving (Show, Eq) -instance Enum NLPOutput where - fromEnum (NL_F) = 0 - fromEnum (NL_G) = 1 - fromEnum (NL_NUM_OUT) = 2 - toEnum (0) = NL_F - toEnum (1) = NL_G - toEnum (2) = NL_NUM_OUT - toEnum k - = error $ "NLPOutput: toEnum: got unhandled number: " ++ show k -instance Marshal NLPOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt NLPOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: NlpSolverInput -data NlpSolverInput = NLP_SOLVER_LAM_G0 - | NLP_SOLVER_LAM_X0 - | NLP_SOLVER_LBG - | NLP_SOLVER_LBX - | NLP_SOLVER_NUM_IN - | NLP_SOLVER_P - | NLP_SOLVER_UBG - | NLP_SOLVER_UBX - | NLP_SOLVER_X0 - deriving (Show, Eq) -instance Enum NlpSolverInput where - fromEnum (NLP_SOLVER_LAM_G0) = 7 - fromEnum (NLP_SOLVER_LAM_X0) = 6 - fromEnum (NLP_SOLVER_LBG) = 4 - fromEnum (NLP_SOLVER_LBX) = 2 - fromEnum (NLP_SOLVER_NUM_IN) = 8 - fromEnum (NLP_SOLVER_P) = 1 - fromEnum (NLP_SOLVER_UBG) = 5 - fromEnum (NLP_SOLVER_UBX) = 3 - fromEnum (NLP_SOLVER_X0) = 0 - toEnum (7) = NLP_SOLVER_LAM_G0 - toEnum (6) = NLP_SOLVER_LAM_X0 - toEnum (4) = NLP_SOLVER_LBG - toEnum (2) = NLP_SOLVER_LBX - toEnum (8) = NLP_SOLVER_NUM_IN - toEnum (1) = NLP_SOLVER_P - toEnum (5) = NLP_SOLVER_UBG - toEnum (3) = NLP_SOLVER_UBX - toEnum (0) = NLP_SOLVER_X0 - toEnum k - = error $ "NlpSolverInput: toEnum: got unhandled number: " ++ - show k -instance Marshal NlpSolverInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt NlpSolverInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: NlpSolverOutput -data NlpSolverOutput = NLP_SOLVER_F - | NLP_SOLVER_G - | NLP_SOLVER_LAM_G - | NLP_SOLVER_LAM_P - | NLP_SOLVER_LAM_X - | NLP_SOLVER_NUM_OUT - | NLP_SOLVER_X - deriving (Show, Eq) -instance Enum NlpSolverOutput where - fromEnum (NLP_SOLVER_F) = 1 - fromEnum (NLP_SOLVER_G) = 2 - fromEnum (NLP_SOLVER_LAM_G) = 4 - fromEnum (NLP_SOLVER_LAM_P) = 5 - fromEnum (NLP_SOLVER_LAM_X) = 3 - fromEnum (NLP_SOLVER_NUM_OUT) = 6 - fromEnum (NLP_SOLVER_X) = 0 - toEnum (1) = NLP_SOLVER_F - toEnum (2) = NLP_SOLVER_G - toEnum (4) = NLP_SOLVER_LAM_G - toEnum (5) = NLP_SOLVER_LAM_P - toEnum (3) = NLP_SOLVER_LAM_X - toEnum (6) = NLP_SOLVER_NUM_OUT - toEnum (0) = NLP_SOLVER_X - toEnum k - = error $ "NlpSolverOutput: toEnum: got unhandled number: " ++ - show k -instance Marshal NlpSolverOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt NlpSolverOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: Operation -data Operation = NUM_BUILT_IN_OPS - | OP_ACOS - | OP_ACOSH - | OP_ADD - | OP_ADDNONZEROS - | OP_AND - | OP_ASIN - | OP_ASINH - | OP_ASSERTION - | OP_ASSIGN - | OP_ATAN - | OP_ATAN2 - | OP_ATANH - | OP_CALL - | OP_CEIL - | OP_CONST - | OP_CONSTPOW - | OP_COPYSIGN - | OP_COS - | OP_COSH - | OP_DETERMINANT - | OP_DIAGCAT - | OP_DIAGSPLIT - | OP_DIV - | OP_EQ - | OP_ERF - | OP_ERFINV - | OP_EXP - | OP_FABS - | OP_FLOOR - | OP_FMAX - | OP_FMIN - | OP_FMOD - | OP_GETNONZEROS - | OP_HORZCAT - | OP_HORZSPLIT - | OP_IF_ELSE_ZERO - | OP_INNER_PROD - | OP_INPUT - | OP_INV - | OP_INVERSE - | OP_LE - | OP_LIFT - | OP_LOG - | OP_LT - | OP_MATMUL - | OP_MUL - | OP_NE - | OP_NEG - | OP_NORM1 - | OP_NORM2 - | OP_NORMF - | OP_NORMINF - | OP_NOT - | OP_OR - | OP_OUTPUT - | OP_PARAMETER - | OP_POW - | OP_PRINTME - | OP_RESHAPE - | OP_SETNONZEROS - | OP_SET_SPARSE - | OP_SIGN - | OP_SIN - | OP_SINH - | OP_SOLVE - | OP_SQ - | OP_SQRT - | OP_SUB - | OP_SUBASSIGN - | OP_SUBREF - | OP_TAN - | OP_TANH - | OP_TRANSPOSE - | OP_TWICE - | OP_VERTCAT - | OP_VERTSPLIT - deriving (Show, Eq) -instance Enum Operation where - fromEnum (NUM_BUILT_IN_OPS) = 76 - fromEnum (OP_ACOS) = 17 - fromEnum (OP_ACOSH) = 41 - fromEnum (OP_ADD) = 1 - fromEnum (OP_ADDNONZEROS) = 65 - fromEnum (OP_AND) = 24 - fromEnum (OP_ASIN) = 16 - fromEnum (OP_ASINH) = 40 - fromEnum (OP_ASSERTION) = 68 - fromEnum (OP_ASSIGN) = 0 - fromEnum (OP_ATAN) = 18 - fromEnum (OP_ATAN2) = 43 - fromEnum (OP_ATANH) = 42 - fromEnum (OP_CALL) = 48 - fromEnum (OP_CEIL) = 27 - fromEnum (OP_CONST) = 44 - fromEnum (OP_CONSTPOW) = 9 - fromEnum (OP_COPYSIGN) = 31 - fromEnum (OP_COS) = 14 - fromEnum (OP_COSH) = 38 - fromEnum (OP_DETERMINANT) = 52 - fromEnum (OP_DIAGCAT) = 57 - fromEnum (OP_DIAGSPLIT) = 60 - fromEnum (OP_DIV) = 4 - fromEnum (OP_EQ) = 21 - fromEnum (OP_ERF) = 33 - fromEnum (OP_ERFINV) = 73 - fromEnum (OP_EXP) = 6 - fromEnum (OP_FABS) = 29 - fromEnum (OP_FLOOR) = 26 - fromEnum (OP_FMAX) = 35 - fromEnum (OP_FMIN) = 34 - fromEnum (OP_FMOD) = 28 - fromEnum (OP_GETNONZEROS) = 64 - fromEnum (OP_HORZCAT) = 55 - fromEnum (OP_HORZSPLIT) = 58 - fromEnum (OP_IF_ELSE_ZERO) = 32 - fromEnum (OP_INNER_PROD) = 54 - fromEnum (OP_INPUT) = 45 - fromEnum (OP_INV) = 36 - fromEnum (OP_INVERSE) = 53 - fromEnum (OP_LE) = 20 - fromEnum (OP_LIFT) = 75 - fromEnum (OP_LOG) = 7 - fromEnum (OP_LT) = 19 - fromEnum (OP_MATMUL) = 49 - fromEnum (OP_MUL) = 3 - fromEnum (OP_NE) = 22 - fromEnum (OP_NEG) = 5 - fromEnum (OP_NORM1) = 70 - fromEnum (OP_NORM2) = 69 - fromEnum (OP_NORMF) = 72 - fromEnum (OP_NORMINF) = 71 - fromEnum (OP_NOT) = 23 - fromEnum (OP_OR) = 25 - fromEnum (OP_OUTPUT) = 46 - fromEnum (OP_PARAMETER) = 47 - fromEnum (OP_POW) = 8 - fromEnum (OP_PRINTME) = 74 - fromEnum (OP_RESHAPE) = 61 - fromEnum (OP_SETNONZEROS) = 66 - fromEnum (OP_SET_SPARSE) = 67 - fromEnum (OP_SIGN) = 30 - fromEnum (OP_SIN) = 13 - fromEnum (OP_SINH) = 37 - fromEnum (OP_SOLVE) = 50 - fromEnum (OP_SQ) = 11 - fromEnum (OP_SQRT) = 10 - fromEnum (OP_SUB) = 2 - fromEnum (OP_SUBASSIGN) = 63 - fromEnum (OP_SUBREF) = 62 - fromEnum (OP_TAN) = 15 - fromEnum (OP_TANH) = 39 - fromEnum (OP_TRANSPOSE) = 51 - fromEnum (OP_TWICE) = 12 - fromEnum (OP_VERTCAT) = 56 - fromEnum (OP_VERTSPLIT) = 59 - toEnum (76) = NUM_BUILT_IN_OPS - toEnum (17) = OP_ACOS - toEnum (41) = OP_ACOSH - toEnum (1) = OP_ADD - toEnum (65) = OP_ADDNONZEROS - toEnum (24) = OP_AND - toEnum (16) = OP_ASIN - toEnum (40) = OP_ASINH - toEnum (68) = OP_ASSERTION - toEnum (0) = OP_ASSIGN - toEnum (18) = OP_ATAN - toEnum (43) = OP_ATAN2 - toEnum (42) = OP_ATANH - toEnum (48) = OP_CALL - toEnum (27) = OP_CEIL - toEnum (44) = OP_CONST - toEnum (9) = OP_CONSTPOW - toEnum (31) = OP_COPYSIGN - toEnum (14) = OP_COS - toEnum (38) = OP_COSH - toEnum (52) = OP_DETERMINANT - toEnum (57) = OP_DIAGCAT - toEnum (60) = OP_DIAGSPLIT - toEnum (4) = OP_DIV - toEnum (21) = OP_EQ - toEnum (33) = OP_ERF - toEnum (73) = OP_ERFINV - toEnum (6) = OP_EXP - toEnum (29) = OP_FABS - toEnum (26) = OP_FLOOR - toEnum (35) = OP_FMAX - toEnum (34) = OP_FMIN - toEnum (28) = OP_FMOD - toEnum (64) = OP_GETNONZEROS - toEnum (55) = OP_HORZCAT - toEnum (58) = OP_HORZSPLIT - toEnum (32) = OP_IF_ELSE_ZERO - toEnum (54) = OP_INNER_PROD - toEnum (45) = OP_INPUT - toEnum (36) = OP_INV - toEnum (53) = OP_INVERSE - toEnum (20) = OP_LE - toEnum (75) = OP_LIFT - toEnum (7) = OP_LOG - toEnum (19) = OP_LT - toEnum (49) = OP_MATMUL - toEnum (3) = OP_MUL - toEnum (22) = OP_NE - toEnum (5) = OP_NEG - toEnum (70) = OP_NORM1 - toEnum (69) = OP_NORM2 - toEnum (72) = OP_NORMF - toEnum (71) = OP_NORMINF - toEnum (23) = OP_NOT - toEnum (25) = OP_OR - toEnum (46) = OP_OUTPUT - toEnum (47) = OP_PARAMETER - toEnum (8) = OP_POW - toEnum (74) = OP_PRINTME - toEnum (61) = OP_RESHAPE - toEnum (66) = OP_SETNONZEROS - toEnum (67) = OP_SET_SPARSE - toEnum (30) = OP_SIGN - toEnum (13) = OP_SIN - toEnum (37) = OP_SINH - toEnum (50) = OP_SOLVE - toEnum (11) = OP_SQ - toEnum (10) = OP_SQRT - toEnum (2) = OP_SUB - toEnum (63) = OP_SUBASSIGN - toEnum (62) = OP_SUBREF - toEnum (15) = OP_TAN - toEnum (39) = OP_TANH - toEnum (51) = OP_TRANSPOSE - toEnum (12) = OP_TWICE - toEnum (56) = OP_VERTCAT - toEnum (59) = OP_VERTSPLIT - toEnum k - = error $ "Operation: toEnum: got unhandled number: " ++ show k -instance Marshal Operation CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt Operation where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: QCQPStruct -data QCQPStruct = QCQP_STRUCT_A - | QCQP_STRUCT_H - | QCQP_STRUCT_NUM - | QCQP_STRUCT_P - deriving (Show, Eq) -instance Enum QCQPStruct where - fromEnum (QCQP_STRUCT_A) = 2 - fromEnum (QCQP_STRUCT_H) = 0 - fromEnum (QCQP_STRUCT_NUM) = 3 - fromEnum (QCQP_STRUCT_P) = 1 - toEnum (2) = QCQP_STRUCT_A - toEnum (0) = QCQP_STRUCT_H - toEnum (3) = QCQP_STRUCT_NUM - toEnum (1) = QCQP_STRUCT_P - toEnum k - = error $ "QCQPStruct: toEnum: got unhandled number: " ++ show k -instance Marshal QCQPStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt QCQPStruct 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 - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt QPStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: QcqpSolverInput -data QcqpSolverInput = QCQP_SOLVER_A - | QCQP_SOLVER_G - | QCQP_SOLVER_H - | QCQP_SOLVER_LAM_X0 - | QCQP_SOLVER_LBA - | QCQP_SOLVER_LBX - | QCQP_SOLVER_NUM_IN - | QCQP_SOLVER_P - | QCQP_SOLVER_Q - | QCQP_SOLVER_R - | QCQP_SOLVER_UBA - | QCQP_SOLVER_UBX - | QCQP_SOLVER_X0 - deriving (Show, Eq) -instance Enum QcqpSolverInput where - fromEnum (QCQP_SOLVER_A) = 5 - fromEnum (QCQP_SOLVER_G) = 1 - fromEnum (QCQP_SOLVER_H) = 0 - fromEnum (QCQP_SOLVER_LAM_X0) = 11 - fromEnum (QCQP_SOLVER_LBA) = 6 - fromEnum (QCQP_SOLVER_LBX) = 8 - fromEnum (QCQP_SOLVER_NUM_IN) = 12 - fromEnum (QCQP_SOLVER_P) = 2 - fromEnum (QCQP_SOLVER_Q) = 3 - fromEnum (QCQP_SOLVER_R) = 4 - fromEnum (QCQP_SOLVER_UBA) = 7 - fromEnum (QCQP_SOLVER_UBX) = 9 - fromEnum (QCQP_SOLVER_X0) = 10 - toEnum (5) = QCQP_SOLVER_A - toEnum (1) = QCQP_SOLVER_G - toEnum (0) = QCQP_SOLVER_H - toEnum (11) = QCQP_SOLVER_LAM_X0 - toEnum (6) = QCQP_SOLVER_LBA - toEnum (8) = QCQP_SOLVER_LBX - toEnum (12) = QCQP_SOLVER_NUM_IN - toEnum (2) = QCQP_SOLVER_P - toEnum (3) = QCQP_SOLVER_Q - toEnum (4) = QCQP_SOLVER_R - toEnum (7) = QCQP_SOLVER_UBA - toEnum (9) = QCQP_SOLVER_UBX - toEnum (10) = QCQP_SOLVER_X0 - toEnum k - = error $ "QcqpSolverInput: toEnum: got unhandled number: " ++ - show k -instance Marshal QcqpSolverInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt QcqpSolverInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: QcqpSolverOutput -data QcqpSolverOutput = QCQP_SOLVER_COST - | QCQP_SOLVER_LAM_A - | QCQP_SOLVER_LAM_X - | QCQP_SOLVER_NUM_OUT - | QCQP_SOLVER_X - deriving (Show, Eq) -instance Enum QcqpSolverOutput where - fromEnum (QCQP_SOLVER_COST) = 1 - fromEnum (QCQP_SOLVER_LAM_A) = 2 - fromEnum (QCQP_SOLVER_LAM_X) = 3 - fromEnum (QCQP_SOLVER_NUM_OUT) = 4 - fromEnum (QCQP_SOLVER_X) = 0 - toEnum (1) = QCQP_SOLVER_COST - toEnum (2) = QCQP_SOLVER_LAM_A - toEnum (3) = QCQP_SOLVER_LAM_X - toEnum (4) = QCQP_SOLVER_NUM_OUT - toEnum (0) = QCQP_SOLVER_X - toEnum k - = error $ "QcqpSolverOutput: toEnum: got unhandled number: " ++ - show k -instance Marshal QcqpSolverOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt QcqpSolverOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: QpSolverInput -data QpSolverInput = QP_SOLVER_A - | QP_SOLVER_G - | QP_SOLVER_H - | QP_SOLVER_LAM_X0 - | QP_SOLVER_LBA - | QP_SOLVER_LBX - | QP_SOLVER_NUM_IN - | QP_SOLVER_UBA - | QP_SOLVER_UBX - | QP_SOLVER_X0 - deriving (Show, Eq) -instance Enum QpSolverInput where - fromEnum (QP_SOLVER_A) = 2 - fromEnum (QP_SOLVER_G) = 1 - fromEnum (QP_SOLVER_H) = 0 - fromEnum (QP_SOLVER_LAM_X0) = 8 - fromEnum (QP_SOLVER_LBA) = 3 - fromEnum (QP_SOLVER_LBX) = 5 - fromEnum (QP_SOLVER_NUM_IN) = 9 - fromEnum (QP_SOLVER_UBA) = 4 - fromEnum (QP_SOLVER_UBX) = 6 - fromEnum (QP_SOLVER_X0) = 7 - toEnum (2) = QP_SOLVER_A - toEnum (1) = QP_SOLVER_G - toEnum (0) = QP_SOLVER_H - toEnum (8) = QP_SOLVER_LAM_X0 - toEnum (3) = QP_SOLVER_LBA - toEnum (5) = QP_SOLVER_LBX - toEnum (9) = QP_SOLVER_NUM_IN - toEnum (4) = QP_SOLVER_UBA - toEnum (6) = QP_SOLVER_UBX - toEnum (7) = QP_SOLVER_X0 - toEnum k - = error $ "QpSolverInput: toEnum: got unhandled number: " ++ show k -instance Marshal QpSolverInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt QpSolverInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: QpSolverOutput -data QpSolverOutput = QP_SOLVER_COST - | QP_SOLVER_LAM_A - | QP_SOLVER_LAM_X - | QP_SOLVER_NUM_OUT - | QP_SOLVER_X - deriving (Show, Eq) -instance Enum QpSolverOutput where - fromEnum (QP_SOLVER_COST) = 1 - fromEnum (QP_SOLVER_LAM_A) = 2 - fromEnum (QP_SOLVER_LAM_X) = 3 - fromEnum (QP_SOLVER_NUM_OUT) = 4 - fromEnum (QP_SOLVER_X) = 0 - toEnum (1) = QP_SOLVER_COST - toEnum (2) = QP_SOLVER_LAM_A - toEnum (3) = QP_SOLVER_LAM_X - toEnum (4) = QP_SOLVER_NUM_OUT - toEnum (0) = QP_SOLVER_X - toEnum k - = error $ "QpSolverOutput: toEnum: got unhandled number: " ++ - show k -instance Marshal QpSolverOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt QpSolverOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: RDAEInput -data RDAEInput = RDAE_NUM_IN - | RDAE_P - | RDAE_RP - | RDAE_RX - | RDAE_RZ - | RDAE_T - | RDAE_X - | RDAE_Z - deriving (Show, Eq) -instance Enum RDAEInput where - fromEnum (RDAE_NUM_IN) = 7 - fromEnum (RDAE_P) = 5 - fromEnum (RDAE_RP) = 2 - fromEnum (RDAE_RX) = 0 - fromEnum (RDAE_RZ) = 1 - fromEnum (RDAE_T) = 6 - fromEnum (RDAE_X) = 3 - fromEnum (RDAE_Z) = 4 - toEnum (7) = RDAE_NUM_IN - toEnum (5) = RDAE_P - toEnum (2) = RDAE_RP - toEnum (0) = RDAE_RX - toEnum (1) = RDAE_RZ - toEnum (6) = RDAE_T - toEnum (3) = RDAE_X - toEnum (4) = RDAE_Z - toEnum k - = error $ "RDAEInput: toEnum: got unhandled number: " ++ show k -instance Marshal RDAEInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt RDAEInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: RDAEOutput -data RDAEOutput = RDAE_ALG - | RDAE_NUM_OUT - | RDAE_ODE - | RDAE_QUAD - deriving (Show, Eq) -instance Enum RDAEOutput where - fromEnum (RDAE_ALG) = 1 - fromEnum (RDAE_NUM_OUT) = 3 - fromEnum (RDAE_ODE) = 0 - fromEnum (RDAE_QUAD) = 2 - toEnum (1) = RDAE_ALG - toEnum (3) = RDAE_NUM_OUT - toEnum (0) = RDAE_ODE - toEnum (2) = RDAE_QUAD - toEnum k - = error $ "RDAEOutput: toEnum: got unhandled number: " ++ show k -instance Marshal RDAEOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt RDAEOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SDPInput -data SDPInput = SDP_SOLVER_A - | SDP_SOLVER_C - | SDP_SOLVER_F - | SDP_SOLVER_G - | SDP_SOLVER_LBA - | SDP_SOLVER_LBX - | SDP_SOLVER_NUM_IN - | SDP_SOLVER_UBA - | SDP_SOLVER_UBX - deriving (Show, Eq) -instance Enum SDPInput where - fromEnum (SDP_SOLVER_A) = 3 - fromEnum (SDP_SOLVER_C) = 1 - fromEnum (SDP_SOLVER_F) = 0 - fromEnum (SDP_SOLVER_G) = 2 - fromEnum (SDP_SOLVER_LBA) = 4 - fromEnum (SDP_SOLVER_LBX) = 6 - fromEnum (SDP_SOLVER_NUM_IN) = 8 - fromEnum (SDP_SOLVER_UBA) = 5 - fromEnum (SDP_SOLVER_UBX) = 7 - toEnum (3) = SDP_SOLVER_A - toEnum (1) = SDP_SOLVER_C - toEnum (0) = SDP_SOLVER_F - toEnum (2) = SDP_SOLVER_G - toEnum (4) = SDP_SOLVER_LBA - toEnum (6) = SDP_SOLVER_LBX - toEnum (8) = SDP_SOLVER_NUM_IN - toEnum (5) = SDP_SOLVER_UBA - toEnum (7) = SDP_SOLVER_UBX - toEnum k - = error $ "SDPInput: toEnum: got unhandled number: " ++ show k -instance Marshal SDPInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SDPInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SDPOutput -data SDPOutput = SDP_SOLVER_COST - | SDP_SOLVER_DUAL - | SDP_SOLVER_DUAL_COST - | SDP_SOLVER_LAM_A - | SDP_SOLVER_LAM_X - | SDP_SOLVER_NUM_OUT - | SDP_SOLVER_P - | SDP_SOLVER_X - deriving (Show, Eq) -instance Enum SDPOutput where - fromEnum (SDP_SOLVER_COST) = 3 - fromEnum (SDP_SOLVER_DUAL) = 2 - fromEnum (SDP_SOLVER_DUAL_COST) = 4 - fromEnum (SDP_SOLVER_LAM_A) = 5 - fromEnum (SDP_SOLVER_LAM_X) = 6 - fromEnum (SDP_SOLVER_NUM_OUT) = 7 - fromEnum (SDP_SOLVER_P) = 1 - fromEnum (SDP_SOLVER_X) = 0 - toEnum (3) = SDP_SOLVER_COST - toEnum (2) = SDP_SOLVER_DUAL - toEnum (4) = SDP_SOLVER_DUAL_COST - toEnum (5) = SDP_SOLVER_LAM_A - toEnum (6) = SDP_SOLVER_LAM_X - toEnum (7) = SDP_SOLVER_NUM_OUT - toEnum (1) = SDP_SOLVER_P - toEnum (0) = SDP_SOLVER_X - toEnum k - = error $ "SDPOutput: toEnum: got unhandled number: " ++ show k -instance Marshal SDPOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SDPOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SDPStruct -data SDPStruct = SDP_STRUCT_A - | SDP_STRUCT_F - | SDP_STRUCT_G - | SDP_STRUCT_NUM - deriving (Show, Eq) -instance Enum SDPStruct where - fromEnum (SDP_STRUCT_A) = 2 - fromEnum (SDP_STRUCT_F) = 0 - fromEnum (SDP_STRUCT_G) = 1 - fromEnum (SDP_STRUCT_NUM) = 3 - toEnum (2) = SDP_STRUCT_A - toEnum (0) = SDP_STRUCT_F - toEnum (1) = SDP_STRUCT_G - toEnum (3) = SDP_STRUCT_NUM - toEnum k - = error $ "SDPStruct: toEnum: got unhandled number: " ++ show k -instance Marshal SDPStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SDPStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SDQPInput -data SDQPInput = SDQP_SOLVER_A - | SDQP_SOLVER_C - | SDQP_SOLVER_F - | SDQP_SOLVER_G - | SDQP_SOLVER_H - | SDQP_SOLVER_LBA - | SDQP_SOLVER_LBX - | SDQP_SOLVER_NUM_IN - | SDQP_SOLVER_UBA - | SDQP_SOLVER_UBX - deriving (Show, Eq) -instance Enum SDQPInput where - fromEnum (SDQP_SOLVER_A) = 4 - fromEnum (SDQP_SOLVER_C) = 1 - fromEnum (SDQP_SOLVER_F) = 2 - fromEnum (SDQP_SOLVER_G) = 3 - fromEnum (SDQP_SOLVER_H) = 0 - fromEnum (SDQP_SOLVER_LBA) = 5 - fromEnum (SDQP_SOLVER_LBX) = 7 - fromEnum (SDQP_SOLVER_NUM_IN) = 9 - fromEnum (SDQP_SOLVER_UBA) = 6 - fromEnum (SDQP_SOLVER_UBX) = 8 - toEnum (4) = SDQP_SOLVER_A - toEnum (1) = SDQP_SOLVER_C - toEnum (2) = SDQP_SOLVER_F - toEnum (3) = SDQP_SOLVER_G - toEnum (0) = SDQP_SOLVER_H - toEnum (5) = SDQP_SOLVER_LBA - toEnum (7) = SDQP_SOLVER_LBX - toEnum (9) = SDQP_SOLVER_NUM_IN - toEnum (6) = SDQP_SOLVER_UBA - toEnum (8) = SDQP_SOLVER_UBX - toEnum k - = error $ "SDQPInput: toEnum: got unhandled number: " ++ show k -instance Marshal SDQPInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SDQPInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SDQPOutput -data SDQPOutput = SDQP_SOLVER_COST - | SDQP_SOLVER_DUAL - | SDQP_SOLVER_DUAL_COST - | SDQP_SOLVER_LAM_A - | SDQP_SOLVER_LAM_X - | SDQP_SOLVER_NUM_OUT - | SDQP_SOLVER_P - | SDQP_SOLVER_X - deriving (Show, Eq) -instance Enum SDQPOutput where - fromEnum (SDQP_SOLVER_COST) = 3 - fromEnum (SDQP_SOLVER_DUAL) = 2 - fromEnum (SDQP_SOLVER_DUAL_COST) = 4 - fromEnum (SDQP_SOLVER_LAM_A) = 5 - fromEnum (SDQP_SOLVER_LAM_X) = 6 - fromEnum (SDQP_SOLVER_NUM_OUT) = 7 - fromEnum (SDQP_SOLVER_P) = 1 - fromEnum (SDQP_SOLVER_X) = 0 - toEnum (3) = SDQP_SOLVER_COST - toEnum (2) = SDQP_SOLVER_DUAL - toEnum (4) = SDQP_SOLVER_DUAL_COST - toEnum (5) = SDQP_SOLVER_LAM_A - toEnum (6) = SDQP_SOLVER_LAM_X - toEnum (7) = SDQP_SOLVER_NUM_OUT - toEnum (1) = SDQP_SOLVER_P - toEnum (0) = SDQP_SOLVER_X - toEnum k - = error $ "SDQPOutput: toEnum: got unhandled number: " ++ show k -instance Marshal SDQPOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SDQPOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SDQPStruct -data SDQPStruct = SDQP_STRUCT_A - | SDQP_STRUCT_F - | SDQP_STRUCT_G - | SDQP_STRUCT_H - | SDQP_STRUCT_NUM - deriving (Show, Eq) -instance Enum SDQPStruct where - fromEnum (SDQP_STRUCT_A) = 3 - fromEnum (SDQP_STRUCT_F) = 1 - fromEnum (SDQP_STRUCT_G) = 2 - fromEnum (SDQP_STRUCT_H) = 0 - fromEnum (SDQP_STRUCT_NUM) = 4 - toEnum (3) = SDQP_STRUCT_A - toEnum (1) = SDQP_STRUCT_F - toEnum (2) = SDQP_STRUCT_G - toEnum (0) = SDQP_STRUCT_H - toEnum (4) = SDQP_STRUCT_NUM - toEnum k - = error $ "SDQPStruct: toEnum: got unhandled number: " ++ show k -instance Marshal SDQPStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SDQPStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SOCPInput -data SOCPInput = SOCP_SOLVER_A - | SOCP_SOLVER_C - | SOCP_SOLVER_E - | SOCP_SOLVER_F - | SOCP_SOLVER_G - | SOCP_SOLVER_H - | SOCP_SOLVER_LBA - | SOCP_SOLVER_LBX - | SOCP_SOLVER_NUM_IN - | SOCP_SOLVER_UBA - | SOCP_SOLVER_UBX - deriving (Show, Eq) -instance Enum SOCPInput where - fromEnum (SOCP_SOLVER_A) = 5 - fromEnum (SOCP_SOLVER_C) = 4 - fromEnum (SOCP_SOLVER_E) = 2 - fromEnum (SOCP_SOLVER_F) = 3 - fromEnum (SOCP_SOLVER_G) = 0 - fromEnum (SOCP_SOLVER_H) = 1 - fromEnum (SOCP_SOLVER_LBA) = 6 - fromEnum (SOCP_SOLVER_LBX) = 8 - fromEnum (SOCP_SOLVER_NUM_IN) = 10 - fromEnum (SOCP_SOLVER_UBA) = 7 - fromEnum (SOCP_SOLVER_UBX) = 9 - toEnum (5) = SOCP_SOLVER_A - toEnum (4) = SOCP_SOLVER_C - toEnum (2) = SOCP_SOLVER_E - toEnum (3) = SOCP_SOLVER_F - toEnum (0) = SOCP_SOLVER_G - toEnum (1) = SOCP_SOLVER_H - toEnum (6) = SOCP_SOLVER_LBA - toEnum (8) = SOCP_SOLVER_LBX - toEnum (10) = SOCP_SOLVER_NUM_IN - toEnum (7) = SOCP_SOLVER_UBA - toEnum (9) = SOCP_SOLVER_UBX - toEnum k - = error $ "SOCPInput: toEnum: got unhandled number: " ++ show k -instance Marshal SOCPInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SOCPInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SOCPOutput -data SOCPOutput = SOCP_SOLVER_COST - | SOCP_SOLVER_DUAL_COST - | SOCP_SOLVER_LAM_A - | SOCP_SOLVER_LAM_CONE - | SOCP_SOLVER_LAM_X - | SOCP_SOLVER_NUM_OUT - | SOCP_SOLVER_X - deriving (Show, Eq) -instance Enum SOCPOutput where - fromEnum (SOCP_SOLVER_COST) = 1 - fromEnum (SOCP_SOLVER_DUAL_COST) = 2 - fromEnum (SOCP_SOLVER_LAM_A) = 3 - fromEnum (SOCP_SOLVER_LAM_CONE) = 5 - fromEnum (SOCP_SOLVER_LAM_X) = 4 - fromEnum (SOCP_SOLVER_NUM_OUT) = 6 - fromEnum (SOCP_SOLVER_X) = 0 - toEnum (1) = SOCP_SOLVER_COST - toEnum (2) = SOCP_SOLVER_DUAL_COST - toEnum (3) = SOCP_SOLVER_LAM_A - toEnum (5) = SOCP_SOLVER_LAM_CONE - toEnum (4) = SOCP_SOLVER_LAM_X - toEnum (6) = SOCP_SOLVER_NUM_OUT - toEnum (0) = SOCP_SOLVER_X - toEnum k - = error $ "SOCPOutput: toEnum: got unhandled number: " ++ show k -instance Marshal SOCPOutput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SOCPOutput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SOCPStruct -data SOCPStruct = SOCP_STRUCT_A - | SOCP_STRUCT_E - | SOCP_STRUCT_G - | SOCP_STRUCT_NUM - deriving (Show, Eq) -instance Enum SOCPStruct where - fromEnum (SOCP_STRUCT_A) = 2 - fromEnum (SOCP_STRUCT_E) = 1 - fromEnum (SOCP_STRUCT_G) = 0 - fromEnum (SOCP_STRUCT_NUM) = 3 - toEnum (2) = SOCP_STRUCT_A - toEnum (1) = SOCP_STRUCT_E - toEnum (0) = SOCP_STRUCT_G - toEnum (3) = SOCP_STRUCT_NUM - toEnum k - = error $ "SOCPStruct: toEnum: got unhandled number: " ++ show k -instance Marshal SOCPStruct CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SOCPStruct where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: SparsityType -data SparsityType = SP_DENSE - | SP_DENSESYM - | SP_DENSETRANS - | SP_SPARSE - | SP_SPARSESYM - deriving (Show, Eq) -instance Enum SparsityType where - fromEnum (SP_DENSE) = 2 - fromEnum (SP_DENSESYM) = 3 - fromEnum (SP_DENSETRANS) = 4 - fromEnum (SP_SPARSE) = 0 - fromEnum (SP_SPARSESYM) = 1 - toEnum (2) = SP_DENSE - toEnum (3) = SP_DENSESYM - toEnum (4) = SP_DENSETRANS - toEnum (0) = SP_SPARSE - toEnum (1) = SP_SPARSESYM - toEnum k - = error $ "SparsityType: toEnum: got unhandled number: " ++ show k -instance Marshal SparsityType CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt SparsityType where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: StabilizedQpSolverInput -data StabilizedQpSolverInput = STABILIZED_QP_SOLVER_A - | STABILIZED_QP_SOLVER_G - | STABILIZED_QP_SOLVER_H - | STABILIZED_QP_SOLVER_LAM_X0 - | STABILIZED_QP_SOLVER_LBA - | STABILIZED_QP_SOLVER_LBX - | STABILIZED_QP_SOLVER_MU - | STABILIZED_QP_SOLVER_MUE - | STABILIZED_QP_SOLVER_MUR - | STABILIZED_QP_SOLVER_NUM_IN - | STABILIZED_QP_SOLVER_UBA - | STABILIZED_QP_SOLVER_UBX - | STABILIZED_QP_SOLVER_X0 - deriving (Show, Eq) -instance Enum StabilizedQpSolverInput where - fromEnum (STABILIZED_QP_SOLVER_A) = 2 - fromEnum (STABILIZED_QP_SOLVER_G) = 1 - fromEnum (STABILIZED_QP_SOLVER_H) = 0 - fromEnum (STABILIZED_QP_SOLVER_LAM_X0) = 8 - fromEnum (STABILIZED_QP_SOLVER_LBA) = 3 - fromEnum (STABILIZED_QP_SOLVER_LBX) = 5 - fromEnum (STABILIZED_QP_SOLVER_MU) = 11 - fromEnum (STABILIZED_QP_SOLVER_MUE) = 10 - fromEnum (STABILIZED_QP_SOLVER_MUR) = 9 - fromEnum (STABILIZED_QP_SOLVER_NUM_IN) = 12 - fromEnum (STABILIZED_QP_SOLVER_UBA) = 4 - fromEnum (STABILIZED_QP_SOLVER_UBX) = 6 - fromEnum (STABILIZED_QP_SOLVER_X0) = 7 - toEnum (2) = STABILIZED_QP_SOLVER_A - toEnum (1) = STABILIZED_QP_SOLVER_G - toEnum (0) = STABILIZED_QP_SOLVER_H - toEnum (8) = STABILIZED_QP_SOLVER_LAM_X0 - toEnum (3) = STABILIZED_QP_SOLVER_LBA - toEnum (5) = STABILIZED_QP_SOLVER_LBX - toEnum (11) = STABILIZED_QP_SOLVER_MU - toEnum (10) = STABILIZED_QP_SOLVER_MUE - toEnum (9) = STABILIZED_QP_SOLVER_MUR - toEnum (12) = STABILIZED_QP_SOLVER_NUM_IN - toEnum (4) = STABILIZED_QP_SOLVER_UBA - toEnum (6) = STABILIZED_QP_SOLVER_UBX - toEnum (7) = STABILIZED_QP_SOLVER_X0 - toEnum k - = error $ "StabilizedQpSolverInput: toEnum: got unhandled number: " - ++ show k -instance Marshal StabilizedQpSolverInput CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt StabilizedQpSolverInput where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: Variability -data Variability = CONSTANT - | CONTINUOUS - | DISCRETE - | PARAMETER - deriving (Show, Eq) -instance Enum Variability where - fromEnum (CONSTANT) = 0 - fromEnum (CONTINUOUS) = 3 - fromEnum (DISCRETE) = 2 - fromEnum (PARAMETER) = 1 - toEnum (0) = CONSTANT - toEnum (3) = CONTINUOUS - toEnum (2) = DISCRETE - toEnum (1) = PARAMETER - toEnum k - = error $ "Variability: toEnum: got unhandled number: " ++ show k -instance Marshal Variability CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt Variability where - wrapReturn = return . toEnum . fromIntegral - --- EnumDecl: opt_type -data Opt_type = OT_BOOLEAN - | OT_BOOLVECTOR - | OT_CALLBACK - | OT_DERIVATIVEGENERATOR - | OT_DICTIONARY - | OT_FUNCTION - | OT_INTEGER - | OT_INTEGERVECTOR - | OT_INTEGERVECTORVECTOR - | OT_REAL - | OT_REALVECTOR - | OT_STRING - | OT_STRINGVECTOR - | OT_UNKNOWN - | OT_VOIDPTR - deriving (Show, Eq) -instance Enum Opt_type where - fromEnum (OT_BOOLEAN) = 0 - fromEnum (OT_BOOLVECTOR) = 6 - fromEnum (OT_CALLBACK) = 12 - fromEnum (OT_DERIVATIVEGENERATOR) = 10 - fromEnum (OT_DICTIONARY) = 9 - fromEnum (OT_FUNCTION) = 11 - fromEnum (OT_INTEGER) = 1 - fromEnum (OT_INTEGERVECTOR) = 4 - fromEnum (OT_INTEGERVECTORVECTOR) = 5 - fromEnum (OT_REAL) = 2 - fromEnum (OT_REALVECTOR) = 7 - fromEnum (OT_STRING) = 3 - fromEnum (OT_STRINGVECTOR) = 8 - fromEnum (OT_UNKNOWN) = 14 - fromEnum (OT_VOIDPTR) = 13 - toEnum (0) = OT_BOOLEAN - toEnum (6) = OT_BOOLVECTOR - toEnum (12) = OT_CALLBACK - toEnum (10) = OT_DERIVATIVEGENERATOR - toEnum (9) = OT_DICTIONARY - toEnum (11) = OT_FUNCTION - toEnum (1) = OT_INTEGER - toEnum (4) = OT_INTEGERVECTOR - toEnum (5) = OT_INTEGERVECTORVECTOR - toEnum (2) = OT_REAL - toEnum (7) = OT_REALVECTOR - toEnum (3) = OT_STRING - toEnum (8) = OT_STRINGVECTOR - toEnum (14) = OT_UNKNOWN - toEnum (13) = OT_VOIDPTR - toEnum k - = error $ "Opt_type: toEnum: got unhandled number: " ++ show k -instance Marshal Opt_type CInt where - marshal = return . fromIntegral . fromEnum -instance WrapReturn CInt Opt_type where + Category(..), + Causality(..), + CollocationPoints(..), + Dynamics(..), + InputOutputScheme(..), + Operation(..), + TypeID(..), + Variability(..), + ) where + + +import Foreign.C.Types ( CInt(..) ) +import Casadi.Internal.Marshal ( Marshal(..) ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) + +-- EnumDecl: Alias +data Alias = ALIAS + | NEGATED_ALIAS + | NO_ALIAS + deriving (Show, Eq) +instance Enum Alias where + fromEnum (ALIAS) = 1 + fromEnum (NEGATED_ALIAS) = 2 + fromEnum (NO_ALIAS) = 0 + toEnum (1) = ALIAS + toEnum (2) = NEGATED_ALIAS + toEnum (0) = NO_ALIAS + toEnum k + = error $ "Alias: toEnum: got unhandled number: " ++ show k +instance Marshal Alias CInt where + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt Alias where + wrapReturn = return . toEnum . fromIntegral + +-- EnumDecl: Category +data Category = CAT_ALGEBRAIC + | CAT_DEPENDENT_CONSTANT + | CAT_DEPENDENT_PARAMETER + | CAT_DERIVATIVE + | CAT_INDEPENDENT_CONSTANT + | CAT_INDEPENDENT_PARAMETER + | CAT_STATE + | CAT_UNKNOWN + deriving (Show, Eq) +instance Enum Category where + fromEnum (CAT_ALGEBRAIC) = 7 + fromEnum (CAT_DEPENDENT_CONSTANT) = 3 + fromEnum (CAT_DEPENDENT_PARAMETER) = 5 + fromEnum (CAT_DERIVATIVE) = 1 + fromEnum (CAT_INDEPENDENT_CONSTANT) = 4 + fromEnum (CAT_INDEPENDENT_PARAMETER) = 6 + fromEnum (CAT_STATE) = 2 + fromEnum (CAT_UNKNOWN) = 0 + toEnum (7) = CAT_ALGEBRAIC + toEnum (3) = CAT_DEPENDENT_CONSTANT + toEnum (5) = CAT_DEPENDENT_PARAMETER + toEnum (1) = CAT_DERIVATIVE + toEnum (4) = CAT_INDEPENDENT_CONSTANT + toEnum (6) = CAT_INDEPENDENT_PARAMETER + toEnum (2) = CAT_STATE + toEnum (0) = CAT_UNKNOWN + toEnum k + = error $ "Category: toEnum: got unhandled number: " ++ show k +instance Marshal Category CInt where + marshal = return . fromIntegral . fromEnum +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 + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt Causality 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 + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt CollocationPoints 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 + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt Dynamics where + wrapReturn = return . toEnum . fromIntegral + +-- EnumDecl: InputOutputScheme +data InputOutputScheme = SCHEME_CLEInput + | SCHEME_CLEOutput + | SCHEME_ControlSimulatorInput + | SCHEME_ControlledDAEInput + | SCHEME_DAEInput + | SCHEME_DAEOutput + | SCHEME_DLEInput + | SCHEME_DLEOutput + | SCHEME_DPLEInput + | SCHEME_DPLEOutput + | SCHEME_GradFInput + | SCHEME_GradFOutput + | SCHEME_HNLPInput + | SCHEME_HessLagInput + | SCHEME_HessLagOutput + | SCHEME_IntegratorInput + | SCHEME_IntegratorOutput + | SCHEME_JacGInput + | SCHEME_JacGOutput + | SCHEME_LR_DLEInput + | SCHEME_LR_DLEOutput + | SCHEME_LR_DPLEInput + | SCHEME_LR_DPLEOutput + | SCHEME_LinsolInput + | SCHEME_LinsolOutput + | SCHEME_LpSolverInput + | SCHEME_LpSolverOutput + | SCHEME_NLPInput + | SCHEME_NLPOutput + | SCHEME_NlpSolverInput + | SCHEME_NlpSolverOutput + | SCHEME_QcqpSolverInput + | SCHEME_QcqpSolverOutput + | SCHEME_QpSolverInput + | SCHEME_QpSolverOutput + | SCHEME_RDAEInput + | SCHEME_RDAEOutput + | SCHEME_SDPInput + | SCHEME_SDPOutput + | SCHEME_SDQPInput + | SCHEME_SDQPOutput + | SCHEME_SOCPInput + | SCHEME_SOCPOutput + | SCHEME_SOCPStruct + | SCHEME_StabilizedQpSolverInput + deriving (Show, Eq) +instance Enum InputOutputScheme where + fromEnum (SCHEME_CLEInput) = 0 + fromEnum (SCHEME_CLEOutput) = 1 + fromEnum (SCHEME_ControlSimulatorInput) = 3 + fromEnum (SCHEME_ControlledDAEInput) = 2 + fromEnum (SCHEME_DAEInput) = 9 + fromEnum (SCHEME_DAEOutput) = 10 + fromEnum (SCHEME_DLEInput) = 4 + fromEnum (SCHEME_DLEOutput) = 5 + fromEnum (SCHEME_DPLEInput) = 6 + fromEnum (SCHEME_DPLEOutput) = 7 + fromEnum (SCHEME_GradFInput) = 25 + fromEnum (SCHEME_GradFOutput) = 26 + fromEnum (SCHEME_HNLPInput) = 8 + fromEnum (SCHEME_HessLagInput) = 29 + fromEnum (SCHEME_HessLagOutput) = 30 + fromEnum (SCHEME_IntegratorInput) = 13 + fromEnum (SCHEME_IntegratorOutput) = 14 + fromEnum (SCHEME_JacGInput) = 27 + fromEnum (SCHEME_JacGOutput) = 28 + fromEnum (SCHEME_LR_DLEInput) = 19 + fromEnum (SCHEME_LR_DLEOutput) = 20 + fromEnum (SCHEME_LR_DPLEInput) = 21 + fromEnum (SCHEME_LR_DPLEOutput) = 22 + fromEnum (SCHEME_LinsolInput) = 15 + fromEnum (SCHEME_LinsolOutput) = 16 + fromEnum (SCHEME_LpSolverInput) = 17 + fromEnum (SCHEME_LpSolverOutput) = 18 + fromEnum (SCHEME_NLPInput) = 23 + fromEnum (SCHEME_NLPOutput) = 24 + fromEnum (SCHEME_NlpSolverInput) = 31 + fromEnum (SCHEME_NlpSolverOutput) = 32 + fromEnum (SCHEME_QcqpSolverInput) = 33 + fromEnum (SCHEME_QcqpSolverOutput) = 34 + fromEnum (SCHEME_QpSolverInput) = 35 + fromEnum (SCHEME_QpSolverOutput) = 36 + fromEnum (SCHEME_RDAEInput) = 11 + fromEnum (SCHEME_RDAEOutput) = 12 + fromEnum (SCHEME_SDPInput) = 37 + fromEnum (SCHEME_SDPOutput) = 38 + fromEnum (SCHEME_SDQPInput) = 39 + fromEnum (SCHEME_SDQPOutput) = 40 + fromEnum (SCHEME_SOCPInput) = 41 + fromEnum (SCHEME_SOCPOutput) = 42 + fromEnum (SCHEME_SOCPStruct) = 43 + fromEnum (SCHEME_StabilizedQpSolverInput) = 44 + toEnum (0) = SCHEME_CLEInput + toEnum (1) = SCHEME_CLEOutput + toEnum (3) = SCHEME_ControlSimulatorInput + toEnum (2) = SCHEME_ControlledDAEInput + toEnum (9) = SCHEME_DAEInput + toEnum (10) = SCHEME_DAEOutput + toEnum (4) = SCHEME_DLEInput + toEnum (5) = SCHEME_DLEOutput + toEnum (6) = SCHEME_DPLEInput + toEnum (7) = SCHEME_DPLEOutput + toEnum (25) = SCHEME_GradFInput + toEnum (26) = SCHEME_GradFOutput + toEnum (8) = SCHEME_HNLPInput + toEnum (29) = SCHEME_HessLagInput + toEnum (30) = SCHEME_HessLagOutput + toEnum (13) = SCHEME_IntegratorInput + toEnum (14) = SCHEME_IntegratorOutput + toEnum (27) = SCHEME_JacGInput + toEnum (28) = SCHEME_JacGOutput + toEnum (19) = SCHEME_LR_DLEInput + toEnum (20) = SCHEME_LR_DLEOutput + toEnum (21) = SCHEME_LR_DPLEInput + toEnum (22) = SCHEME_LR_DPLEOutput + toEnum (15) = SCHEME_LinsolInput + toEnum (16) = SCHEME_LinsolOutput + toEnum (17) = SCHEME_LpSolverInput + toEnum (18) = SCHEME_LpSolverOutput + toEnum (23) = SCHEME_NLPInput + toEnum (24) = SCHEME_NLPOutput + toEnum (31) = SCHEME_NlpSolverInput + toEnum (32) = SCHEME_NlpSolverOutput + toEnum (33) = SCHEME_QcqpSolverInput + toEnum (34) = SCHEME_QcqpSolverOutput + toEnum (35) = SCHEME_QpSolverInput + toEnum (36) = SCHEME_QpSolverOutput + toEnum (11) = SCHEME_RDAEInput + toEnum (12) = SCHEME_RDAEOutput + toEnum (37) = SCHEME_SDPInput + toEnum (38) = SCHEME_SDPOutput + toEnum (39) = SCHEME_SDQPInput + toEnum (40) = SCHEME_SDQPOutput + toEnum (41) = SCHEME_SOCPInput + toEnum (42) = SCHEME_SOCPOutput + toEnum (43) = SCHEME_SOCPStruct + toEnum (44) = SCHEME_StabilizedQpSolverInput + toEnum k + = error $ "InputOutputScheme: toEnum: got unhandled number: " ++ + show k +instance Marshal InputOutputScheme CInt where + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt InputOutputScheme where + wrapReturn = return . toEnum . fromIntegral + +-- EnumDecl: Operation +data Operation = NUM_BUILT_IN_OPS + | OP_ACOS + | OP_ACOSH + | OP_ADD + | OP_ADDNONZEROS + | OP_AND + | OP_ASIN + | OP_ASINH + | OP_ASSERTION + | OP_ASSIGN + | OP_ATAN + | OP_ATAN2 + | OP_ATANH + | OP_CALL + | OP_CEIL + | OP_CONST + | OP_CONSTPOW + | OP_COPYSIGN + | OP_COS + | OP_COSH + | OP_DETERMINANT + | OP_DIAGCAT + | OP_DIAGSPLIT + | OP_DIV + | OP_EQ + | OP_ERF + | OP_ERFINV + | OP_EXP + | OP_FABS + | OP_FIND + | OP_FLOOR + | OP_FMAX + | OP_FMIN + | OP_FMOD + | OP_GETNONZEROS + | OP_HORZCAT + | OP_HORZREPMAT + | OP_HORZREPSUM + | OP_HORZSPLIT + | OP_IF_ELSE_ZERO + | OP_INNER_PROD + | OP_INPUT + | OP_INV + | OP_INVERSE + | OP_LE + | OP_LIFT + | OP_LOG + | OP_LT + | OP_MAP + | OP_MATMUL + | OP_MONITOR + | OP_MUL + | OP_NE + | OP_NEG + | OP_NORM1 + | OP_NORM2 + | OP_NORMF + | OP_NORMINF + | OP_NOT + | OP_OR + | OP_OUTPUT + | OP_PARAMETER + | OP_POW + | OP_PRINTME + | OP_PROJECT + | OP_RESHAPE + | OP_SETNONZEROS + | OP_SIGN + | OP_SIN + | OP_SINH + | OP_SOLVE + | OP_SQ + | OP_SQRT + | OP_SUB + | OP_SUBASSIGN + | OP_SUBREF + | OP_TAN + | OP_TANH + | OP_TRANSPOSE + | OP_TWICE + | OP_VERTCAT + | OP_VERTSPLIT + deriving (Show, Eq) +instance Enum Operation where + fromEnum (NUM_BUILT_IN_OPS) = 81 + fromEnum (OP_ACOS) = 17 + fromEnum (OP_ACOSH) = 41 + fromEnum (OP_ADD) = 1 + fromEnum (OP_ADDNONZEROS) = 67 + fromEnum (OP_AND) = 24 + fromEnum (OP_ASIN) = 16 + fromEnum (OP_ASINH) = 40 + fromEnum (OP_ASSERTION) = 70 + fromEnum (OP_ASSIGN) = 0 + fromEnum (OP_ATAN) = 18 + fromEnum (OP_ATAN2) = 43 + fromEnum (OP_ATANH) = 42 + fromEnum (OP_CALL) = 48 + fromEnum (OP_CEIL) = 27 + fromEnum (OP_CONST) = 44 + fromEnum (OP_CONSTPOW) = 9 + fromEnum (OP_COPYSIGN) = 31 + fromEnum (OP_COS) = 14 + fromEnum (OP_COSH) = 38 + fromEnum (OP_DETERMINANT) = 54 + fromEnum (OP_DIAGCAT) = 59 + fromEnum (OP_DIAGSPLIT) = 62 + fromEnum (OP_DIV) = 4 + fromEnum (OP_EQ) = 21 + fromEnum (OP_ERF) = 33 + fromEnum (OP_ERFINV) = 78 + fromEnum (OP_EXP) = 6 + fromEnum (OP_FABS) = 29 + fromEnum (OP_FIND) = 49 + fromEnum (OP_FLOOR) = 26 + fromEnum (OP_FMAX) = 35 + fromEnum (OP_FMIN) = 34 + fromEnum (OP_FMOD) = 28 + fromEnum (OP_GETNONZEROS) = 66 + fromEnum (OP_HORZCAT) = 57 + fromEnum (OP_HORZREPMAT) = 76 + fromEnum (OP_HORZREPSUM) = 77 + fromEnum (OP_HORZSPLIT) = 60 + fromEnum (OP_IF_ELSE_ZERO) = 32 + fromEnum (OP_INNER_PROD) = 56 + fromEnum (OP_INPUT) = 45 + fromEnum (OP_INV) = 36 + fromEnum (OP_INVERSE) = 55 + fromEnum (OP_LE) = 20 + fromEnum (OP_LIFT) = 80 + fromEnum (OP_LOG) = 7 + fromEnum (OP_LT) = 19 + fromEnum (OP_MAP) = 50 + fromEnum (OP_MATMUL) = 51 + fromEnum (OP_MONITOR) = 71 + fromEnum (OP_MUL) = 3 + fromEnum (OP_NE) = 22 + fromEnum (OP_NEG) = 5 + fromEnum (OP_NORM1) = 73 + fromEnum (OP_NORM2) = 72 + fromEnum (OP_NORMF) = 75 + fromEnum (OP_NORMINF) = 74 + fromEnum (OP_NOT) = 23 + fromEnum (OP_OR) = 25 + fromEnum (OP_OUTPUT) = 46 + fromEnum (OP_PARAMETER) = 47 + fromEnum (OP_POW) = 8 + fromEnum (OP_PRINTME) = 79 + fromEnum (OP_PROJECT) = 69 + fromEnum (OP_RESHAPE) = 63 + fromEnum (OP_SETNONZEROS) = 68 + fromEnum (OP_SIGN) = 30 + fromEnum (OP_SIN) = 13 + fromEnum (OP_SINH) = 37 + fromEnum (OP_SOLVE) = 52 + fromEnum (OP_SQ) = 11 + fromEnum (OP_SQRT) = 10 + fromEnum (OP_SUB) = 2 + fromEnum (OP_SUBASSIGN) = 65 + fromEnum (OP_SUBREF) = 64 + fromEnum (OP_TAN) = 15 + fromEnum (OP_TANH) = 39 + fromEnum (OP_TRANSPOSE) = 53 + fromEnum (OP_TWICE) = 12 + fromEnum (OP_VERTCAT) = 58 + fromEnum (OP_VERTSPLIT) = 61 + toEnum (81) = NUM_BUILT_IN_OPS + toEnum (17) = OP_ACOS + toEnum (41) = OP_ACOSH + toEnum (1) = OP_ADD + toEnum (67) = OP_ADDNONZEROS + toEnum (24) = OP_AND + toEnum (16) = OP_ASIN + toEnum (40) = OP_ASINH + toEnum (70) = OP_ASSERTION + toEnum (0) = OP_ASSIGN + toEnum (18) = OP_ATAN + toEnum (43) = OP_ATAN2 + toEnum (42) = OP_ATANH + toEnum (48) = OP_CALL + toEnum (27) = OP_CEIL + toEnum (44) = OP_CONST + toEnum (9) = OP_CONSTPOW + toEnum (31) = OP_COPYSIGN + toEnum (14) = OP_COS + toEnum (38) = OP_COSH + toEnum (54) = OP_DETERMINANT + toEnum (59) = OP_DIAGCAT + toEnum (62) = OP_DIAGSPLIT + toEnum (4) = OP_DIV + toEnum (21) = OP_EQ + toEnum (33) = OP_ERF + toEnum (78) = OP_ERFINV + toEnum (6) = OP_EXP + toEnum (29) = OP_FABS + toEnum (49) = OP_FIND + toEnum (26) = OP_FLOOR + toEnum (35) = OP_FMAX + toEnum (34) = OP_FMIN + toEnum (28) = OP_FMOD + toEnum (66) = OP_GETNONZEROS + toEnum (57) = OP_HORZCAT + toEnum (76) = OP_HORZREPMAT + toEnum (77) = OP_HORZREPSUM + toEnum (60) = OP_HORZSPLIT + toEnum (32) = OP_IF_ELSE_ZERO + toEnum (56) = OP_INNER_PROD + toEnum (45) = OP_INPUT + toEnum (36) = OP_INV + toEnum (55) = OP_INVERSE + toEnum (20) = OP_LE + toEnum (80) = OP_LIFT + toEnum (7) = OP_LOG + toEnum (19) = OP_LT + toEnum (50) = OP_MAP + toEnum (51) = OP_MATMUL + toEnum (71) = OP_MONITOR + toEnum (3) = OP_MUL + toEnum (22) = OP_NE + toEnum (5) = OP_NEG + toEnum (73) = OP_NORM1 + toEnum (72) = OP_NORM2 + toEnum (75) = OP_NORMF + toEnum (74) = OP_NORMINF + toEnum (23) = OP_NOT + toEnum (25) = OP_OR + toEnum (46) = OP_OUTPUT + toEnum (47) = OP_PARAMETER + toEnum (8) = OP_POW + toEnum (79) = OP_PRINTME + toEnum (69) = OP_PROJECT + toEnum (63) = OP_RESHAPE + toEnum (68) = OP_SETNONZEROS + toEnum (30) = OP_SIGN + toEnum (13) = OP_SIN + toEnum (37) = OP_SINH + toEnum (52) = OP_SOLVE + toEnum (11) = OP_SQ + toEnum (10) = OP_SQRT + toEnum (2) = OP_SUB + toEnum (65) = OP_SUBASSIGN + toEnum (64) = OP_SUBREF + toEnum (15) = OP_TAN + toEnum (39) = OP_TANH + toEnum (53) = OP_TRANSPOSE + toEnum (12) = OP_TWICE + toEnum (58) = OP_VERTCAT + toEnum (61) = OP_VERTSPLIT + toEnum k + = error $ "Operation: toEnum: got unhandled number: " ++ show k +instance Marshal Operation CInt where + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt Operation where + wrapReturn = return . toEnum . fromIntegral + +-- EnumDecl: TypeID +data TypeID = OT_BOOLEAN + | OT_BOOLVECTOR + | OT_CALLBACK + | OT_DERIVATIVEGENERATOR + | OT_DICT + | OT_FUNCTION + | OT_INTEGER + | OT_INTEGERVECTOR + | OT_INTEGERVECTORVECTOR + | OT_NULL + | OT_REAL + | OT_REALVECTOR + | OT_STRING + | OT_STRINGVECTOR + | OT_UNKNOWN + | OT_VOIDPTR + deriving (Show, Eq) +instance Enum TypeID where + fromEnum (OT_BOOLEAN) = 1 + fromEnum (OT_BOOLVECTOR) = 7 + fromEnum (OT_CALLBACK) = 13 + fromEnum (OT_DERIVATIVEGENERATOR) = 11 + fromEnum (OT_DICT) = 10 + fromEnum (OT_FUNCTION) = 12 + fromEnum (OT_INTEGER) = 2 + fromEnum (OT_INTEGERVECTOR) = 5 + fromEnum (OT_INTEGERVECTORVECTOR) = 6 + fromEnum (OT_NULL) = 0 + fromEnum (OT_REAL) = 3 + fromEnum (OT_REALVECTOR) = 8 + fromEnum (OT_STRING) = 4 + fromEnum (OT_STRINGVECTOR) = 9 + fromEnum (OT_UNKNOWN) = 15 + fromEnum (OT_VOIDPTR) = 14 + toEnum (1) = OT_BOOLEAN + toEnum (7) = OT_BOOLVECTOR + toEnum (13) = OT_CALLBACK + toEnum (11) = OT_DERIVATIVEGENERATOR + toEnum (10) = OT_DICT + toEnum (12) = OT_FUNCTION + toEnum (2) = OT_INTEGER + toEnum (5) = OT_INTEGERVECTOR + toEnum (6) = OT_INTEGERVECTORVECTOR + toEnum (0) = OT_NULL + toEnum (3) = OT_REAL + toEnum (8) = OT_REALVECTOR + toEnum (4) = OT_STRING + toEnum (9) = OT_STRINGVECTOR + toEnum (15) = OT_UNKNOWN + toEnum (14) = OT_VOIDPTR + toEnum k + = error $ "TypeID: toEnum: got unhandled number: " ++ show k +instance Marshal TypeID CInt where + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt TypeID where + wrapReturn = return . toEnum . fromIntegral + +-- EnumDecl: Variability +data Variability = CONSTANT + | CONTINUOUS + | DISCRETE + | PARAMETER + deriving (Show, Eq) +instance Enum Variability where + fromEnum (CONSTANT) = 0 + fromEnum (CONTINUOUS) = 3 + fromEnum (DISCRETE) = 2 + fromEnum (PARAMETER) = 1 + toEnum (0) = CONSTANT + toEnum (3) = CONTINUOUS + toEnum (2) = DISCRETE + toEnum (1) = PARAMETER + toEnum k + = error $ "Variability: toEnum: got unhandled number: " ++ show k +instance Marshal Variability CInt where + marshal = return . fromIntegral . fromEnum +instance WrapReturn CInt Variability where wrapReturn = return . toEnum . fromIntegral diff --git a/Casadi/Core/Tools.hs b/Casadi/Core/Tools.hs --- a/Casadi/Core/Tools.hs +++ b/Casadi/Core/Tools.hs @@ -2,20685 +2,43781 @@ module Casadi.Core.Tools ( - cleIn__0, - cleIn__1, - cleIn__10, - cleIn__11, - cleIn__2, - cleIn__3, - cleIn__4, - cleIn__5, - cleIn__6, - cleIn__7, - cleIn__8, - cleIn__9, - cleOut__0, - cleOut__1, - cleOut__2, - cleOut__3, - cleOut__4, - cleOut__5, - cleOut__6, - cleOut__7, - cleStruct__0, - cleStruct__1, - cleStruct__2, - cleStruct__3, - collocationPoints__0, - collocationPoints__1, - complement, - controldaeIn__0, - controldaeIn__1, - controldaeIn__10, - controldaeIn__11, - controldaeIn__12, - controldaeIn__13, - controldaeIn__14, - controldaeIn__15, - controldaeIn__16, - controldaeIn__17, - controldaeIn__18, - controldaeIn__19, - controldaeIn__2, - controldaeIn__20, - controldaeIn__21, - controldaeIn__22, - controldaeIn__23, - controldaeIn__24, - controldaeIn__25, - controldaeIn__26, - controldaeIn__27, - controldaeIn__28, - controldaeIn__29, - controldaeIn__3, - controldaeIn__30, - controldaeIn__31, - controldaeIn__32, - controldaeIn__33, - controldaeIn__34, - controldaeIn__35, - controldaeIn__36, - controldaeIn__37, - controldaeIn__38, - controldaeIn__39, - controldaeIn__4, - controldaeIn__5, - controldaeIn__6, - controldaeIn__7, - controldaeIn__8, - controldaeIn__9, - controlsimulatorIn__0, - controlsimulatorIn__1, - controlsimulatorIn__10, - controlsimulatorIn__11, - controlsimulatorIn__12, - controlsimulatorIn__13, - controlsimulatorIn__14, - controlsimulatorIn__15, - controlsimulatorIn__2, - controlsimulatorIn__3, - controlsimulatorIn__4, - controlsimulatorIn__5, - controlsimulatorIn__6, - controlsimulatorIn__7, - controlsimulatorIn__8, - controlsimulatorIn__9, - countNodes__0, - countNodes__1, - createParent__0, - createParent__1, - createParent__2, - daeIn__0, - daeIn__1, - daeIn__10, - daeIn__11, - daeIn__12, - daeIn__13, - daeIn__14, - daeIn__15, - daeIn__16, - daeIn__17, - daeIn__18, - daeIn__19, - daeIn__2, - daeIn__3, - daeIn__4, - daeIn__5, - daeIn__6, - daeIn__7, - daeIn__8, - daeIn__9, - daeOut__0, - daeOut__1, - daeOut__10, - daeOut__11, - daeOut__12, - daeOut__13, - daeOut__14, - daeOut__15, - daeOut__2, - daeOut__3, - daeOut__4, - daeOut__5, - daeOut__6, - daeOut__7, - daeOut__8, - daeOut__9, - dependsOn__0, - dependsOn__1, - dleIn__0, - dleIn__1, - dleIn__10, - dleIn__11, - dleIn__2, - dleIn__3, - dleIn__4, - dleIn__5, - dleIn__6, - dleIn__7, - dleIn__8, - dleIn__9, - dleOut__0, - dleOut__1, - dleOut__2, - dleOut__3, - dleOut__4, - dleOut__5, - dleOut__6, - dleOut__7, - dleStruct__0, - dleStruct__1, - dleStruct__2, - dpleIn__0, - dpleIn__1, - dpleIn__10, - dpleIn__11, - dpleIn__2, - dpleIn__3, - dpleIn__4, - dpleIn__5, - dpleIn__6, - dpleIn__7, - dpleIn__8, - dpleIn__9, - dpleOut__0, - dpleOut__1, - dpleOut__2, - dpleOut__3, - dpleOut__4, - dpleOut__5, - dpleOut__6, - dpleOut__7, - dpleStruct__0, - dpleStruct__1, - dpleStruct__2, - eig_symbolic, - evalf__0, - evalf__1, - expand, - extractShared__0, - extractShared__1, - extractShared__2, - extractShared__3, - extractShared__4, - extractShared__5, - gauss_quadrature__0, - gauss_quadrature__1, - gauss_quadrature__2, - getFree, - getOperatorRepresentation__0, - getOperatorRepresentation__1, - getSchemeEntryDoc, - getSchemeEntryEnum, - getSchemeEntryEnumName, - getSchemeEntryName, - getSchemeEntryNames, - getSchemeName, - getSchemeSize, - getSymbols__0, - getSymbols__1, - getSymbols__2, - gradFIn__0, - gradFIn__1, - gradFIn__10, - gradFIn__11, - gradFIn__2, - gradFIn__3, - gradFIn__4, - gradFIn__5, - gradFIn__6, - gradFIn__7, - gradFIn__8, - gradFIn__9, - gradFOut__0, - gradFOut__1, - gradFOut__10, - gradFOut__11, - gradFOut__12, - gradFOut__13, - gradFOut__14, - gradFOut__15, - gradFOut__2, - gradFOut__3, - gradFOut__4, - gradFOut__5, - gradFOut__6, - gradFOut__7, - gradFOut__8, - gradFOut__9, - gradient__0, - gradient__1, - graph_substitute__0, - graph_substitute__1, - heaviside, - hessLagIn__0, - hessLagIn__1, - hessLagIn__10, - hessLagIn__11, - hessLagIn__12, - hessLagIn__13, - hessLagIn__14, - hessLagIn__15, - hessLagIn__16, - hessLagIn__17, - hessLagIn__18, - hessLagIn__19, - hessLagIn__2, - hessLagIn__3, - hessLagIn__4, - hessLagIn__5, - hessLagIn__6, - hessLagIn__7, - hessLagIn__8, - hessLagIn__9, - hessLagOut__0, - hessLagOut__1, - hessLagOut__10, - hessLagOut__11, - hessLagOut__12, - hessLagOut__13, - hessLagOut__14, - hessLagOut__15, - hessLagOut__16, - hessLagOut__17, - hessLagOut__18, - hessLagOut__19, - hessLagOut__2, - hessLagOut__20, - hessLagOut__21, - hessLagOut__22, - hessLagOut__23, - hessLagOut__3, - hessLagOut__4, - hessLagOut__5, - hessLagOut__6, - hessLagOut__7, - hessLagOut__8, - hessLagOut__9, - hessian__0, - hessian__1, - hessian__2, - hessian__3, - hnlpIn__0, - hnlpIn__1, - hnlpIn__10, - hnlpIn__11, - hnlpIn__12, - hnlpIn__13, - hnlpIn__14, - hnlpIn__15, - hnlpIn__2, - hnlpIn__3, - hnlpIn__4, - hnlpIn__5, - hnlpIn__6, - hnlpIn__7, - hnlpIn__8, - hnlpIn__9, - integratorIn__0, - integratorIn__1, - integratorIn__10, - integratorIn__11, - integratorIn__12, - integratorIn__13, - integratorIn__14, - integratorIn__15, - integratorIn__16, - integratorIn__17, - integratorIn__18, - integratorIn__19, - integratorIn__2, - integratorIn__20, - integratorIn__21, - integratorIn__22, - integratorIn__23, - integratorIn__24, - integratorIn__25, - integratorIn__26, - integratorIn__27, - integratorIn__3, - integratorIn__4, - integratorIn__5, - integratorIn__6, - integratorIn__7, - integratorIn__8, - integratorIn__9, - integratorOut__0, - integratorOut__1, - integratorOut__10, - integratorOut__11, - integratorOut__12, - integratorOut__13, - integratorOut__14, - integratorOut__15, - integratorOut__16, - integratorOut__17, - integratorOut__18, - integratorOut__19, - integratorOut__2, - integratorOut__20, - integratorOut__21, - integratorOut__22, - integratorOut__23, - integratorOut__24, - integratorOut__25, - integratorOut__26, - integratorOut__27, - integratorOut__3, - integratorOut__4, - integratorOut__5, - integratorOut__6, - integratorOut__7, - integratorOut__8, - integratorOut__9, - isDecreasing__0, - isDecreasing__1, - isIncreasing__0, - isIncreasing__1, - isMonotone__0, - isMonotone__1, - isNonDecreasing__0, - isNonDecreasing__1, - isNonIncreasing__0, - isNonIncreasing__1, - isRegular__0, - isRegular__1, - isStrictlyMonotone__0, - isStrictlyMonotone__1, - jacGIn__0, - jacGIn__1, - jacGIn__10, - jacGIn__11, - jacGIn__2, - jacGIn__3, - jacGIn__4, - jacGIn__5, - jacGIn__6, - jacGIn__7, - jacGIn__8, - jacGIn__9, - jacGOut__0, - jacGOut__1, - jacGOut__10, - jacGOut__11, - jacGOut__12, - jacGOut__13, - jacGOut__14, - jacGOut__15, - jacGOut__2, - jacGOut__3, - jacGOut__4, - jacGOut__5, - jacGOut__6, - jacGOut__7, - jacGOut__8, - jacGOut__9, - jacobianTimesVector__0, - jacobianTimesVector__1, - jacobian__0, - jacobian__1, - linsolIn__0, - linsolIn__1, - linsolIn__10, - linsolIn__11, - linsolIn__2, - linsolIn__3, - linsolIn__4, - linsolIn__5, - linsolIn__6, - linsolIn__7, - linsolIn__8, - linsolIn__9, - linsolOut__0, - linsolOut__1, - linsolOut__2, - linsolOut__3, - linsolOut__4, - linsolOut__5, - linsolOut__6, - linsolOut__7, - logic_and__0, - logic_and__1, - logic_and__2, - logic_and__3, - logic_and__4, - logic_and__5, - logic_not__0, - logic_not__1, - logic_not__2, - logic_not__3, - logic_not__4, - logic_not__5, - logic_or__0, - logic_or__1, - logic_or__2, - logic_or__3, - logic_or__4, - logic_or__5, - lookupvector, - lpIn__0, - lpIn__1, - lpIn__10, - lpIn__11, - lpIn__12, - lpIn__13, - lpIn__14, - lpIn__15, - lpIn__16, - lpIn__17, - lpIn__18, - lpIn__19, - lpIn__2, - lpIn__20, - lpIn__21, - lpIn__22, - lpIn__23, - lpIn__24, - lpIn__25, - lpIn__26, - lpIn__27, - lpIn__3, - lpIn__4, - lpIn__5, - lpIn__6, - lpIn__7, - lpIn__8, - lpIn__9, - lpOut__0, - lpOut__1, - lpOut__10, - lpOut__11, - lpOut__12, - lpOut__13, - lpOut__14, - lpOut__15, - lpOut__16, - lpOut__17, - lpOut__18, - lpOut__19, - lpOut__2, - lpOut__3, - lpOut__4, - lpOut__5, - lpOut__6, - lpOut__7, - lpOut__8, - lpOut__9, - lpStruct__0, - lpStruct__1, - lrdleIn__0, - lrdleIn__1, - lrdleIn__10, - lrdleIn__11, - lrdleIn__12, - lrdleIn__13, - lrdleIn__14, - lrdleIn__15, - lrdleIn__16, - lrdleIn__17, - lrdleIn__18, - lrdleIn__19, - lrdleIn__2, - lrdleIn__3, - lrdleIn__4, - lrdleIn__5, - lrdleIn__6, - lrdleIn__7, - lrdleIn__8, - lrdleIn__9, - lrdleOut__0, - lrdleOut__1, - lrdleOut__2, - lrdleOut__3, - lrdleOut__4, - lrdleOut__5, - lrdleOut__6, - lrdleOut__7, - lrdleStruct__0, - lrdleStruct__1, - lrdleStruct__2, - lrdleStruct__3, - lrdleStruct__4, - lrdpleIn__0, - lrdpleIn__1, - lrdpleIn__10, - lrdpleIn__11, - lrdpleIn__12, - lrdpleIn__13, - lrdpleIn__14, - lrdpleIn__15, - lrdpleIn__16, - lrdpleIn__17, - lrdpleIn__18, - lrdpleIn__19, - lrdpleIn__2, - lrdpleIn__3, - lrdpleIn__4, - lrdpleIn__5, - lrdpleIn__6, - lrdpleIn__7, - lrdpleIn__8, - lrdpleIn__9, - lrdpleOut__0, - lrdpleOut__1, - lrdpleOut__2, - lrdpleOut__3, - lrdpleOut__4, - lrdpleOut__5, - lrdpleOut__6, - lrdpleOut__7, - lrdpleStruct__0, - lrdpleStruct__1, - lrdpleStruct__2, - lrdpleStruct__3, - lrdpleStruct__4, - matrix_expand__0, - matrix_expand__1, - matrix_expand__2, - matrix_expand__3, - mtaylor__0, - mtaylor__1, - mtaylor__2, - nlpIn__0, - nlpIn__1, - nlpIn__10, - nlpIn__11, - nlpIn__2, - nlpIn__3, - nlpIn__4, - nlpIn__5, - nlpIn__6, - nlpIn__7, - nlpIn__8, - nlpIn__9, - nlpOut__0, - nlpOut__1, - nlpOut__10, - nlpOut__11, - nlpOut__2, - nlpOut__3, - nlpOut__4, - nlpOut__5, - nlpOut__6, - nlpOut__7, - nlpOut__8, - nlpOut__9, - nlpSolverIn__0, - nlpSolverIn__1, - nlpSolverIn__10, - nlpSolverIn__11, - nlpSolverIn__12, - nlpSolverIn__13, - nlpSolverIn__14, - nlpSolverIn__15, - nlpSolverIn__16, - nlpSolverIn__17, - nlpSolverIn__18, - nlpSolverIn__19, - nlpSolverIn__2, - nlpSolverIn__20, - nlpSolverIn__21, - nlpSolverIn__22, - nlpSolverIn__23, - nlpSolverIn__24, - nlpSolverIn__25, - nlpSolverIn__26, - nlpSolverIn__27, - nlpSolverIn__28, - nlpSolverIn__29, - nlpSolverIn__3, - nlpSolverIn__30, - nlpSolverIn__31, - nlpSolverIn__32, - nlpSolverIn__33, - nlpSolverIn__34, - nlpSolverIn__35, - nlpSolverIn__4, - nlpSolverIn__5, - nlpSolverIn__6, - nlpSolverIn__7, - nlpSolverIn__8, - nlpSolverIn__9, - nlpSolverOut__0, - nlpSolverOut__1, - nlpSolverOut__10, - nlpSolverOut__11, - nlpSolverOut__12, - nlpSolverOut__13, - nlpSolverOut__14, - nlpSolverOut__15, - nlpSolverOut__16, - nlpSolverOut__17, - nlpSolverOut__18, - nlpSolverOut__19, - nlpSolverOut__2, - nlpSolverOut__20, - nlpSolverOut__21, - nlpSolverOut__22, - nlpSolverOut__23, - nlpSolverOut__24, - nlpSolverOut__25, - nlpSolverOut__26, - nlpSolverOut__27, - nlpSolverOut__3, - nlpSolverOut__4, - nlpSolverOut__5, - nlpSolverOut__6, - nlpSolverOut__7, - nlpSolverOut__8, - nlpSolverOut__9, - pinv__0, - pinv__1, - pinv__2, - pinv__3, - pinv__4, - poly_coeff, - poly_roots, - printCompact__0, - printCompact__1, - pw_const, - pw_lin, - qcqpIn__0, - qcqpIn__1, - qcqpIn__10, - qcqpIn__11, - qcqpIn__12, - qcqpIn__13, - qcqpIn__14, - qcqpIn__15, - qcqpIn__16, - qcqpIn__17, - qcqpIn__18, - qcqpIn__19, - qcqpIn__2, - qcqpIn__20, - qcqpIn__21, - qcqpIn__22, - qcqpIn__23, - qcqpIn__24, - qcqpIn__25, - qcqpIn__26, - qcqpIn__27, - qcqpIn__28, - qcqpIn__29, - qcqpIn__3, - qcqpIn__30, - qcqpIn__31, - qcqpIn__32, - qcqpIn__33, - qcqpIn__34, - qcqpIn__35, - qcqpIn__36, - qcqpIn__37, - qcqpIn__38, - qcqpIn__39, - qcqpIn__4, - qcqpIn__40, - qcqpIn__41, - qcqpIn__42, - qcqpIn__43, - qcqpIn__44, - qcqpIn__45, - qcqpIn__46, - qcqpIn__47, - qcqpIn__48, - qcqpIn__49, - qcqpIn__5, - qcqpIn__50, - qcqpIn__51, - qcqpIn__6, - qcqpIn__7, - qcqpIn__8, - qcqpIn__9, - qcqpOut__0, - qcqpOut__1, - qcqpOut__10, - qcqpOut__11, - qcqpOut__12, - qcqpOut__13, - qcqpOut__14, - qcqpOut__15, - qcqpOut__16, - qcqpOut__17, - qcqpOut__18, - qcqpOut__19, - qcqpOut__2, - qcqpOut__3, - qcqpOut__4, - qcqpOut__5, - qcqpOut__6, - qcqpOut__7, - qcqpOut__8, - qcqpOut__9, - qcqpStruct__0, - qcqpStruct__1, - qcqpStruct__2, - qcqpStruct__3, - qpIn__0, - qpIn__1, - qpIn__10, - qpIn__11, - qpIn__12, - qpIn__13, - qpIn__14, - qpIn__15, - qpIn__16, - qpIn__17, - qpIn__18, - qpIn__19, - qpIn__2, - qpIn__20, - qpIn__21, - qpIn__22, - qpIn__23, - qpIn__24, - qpIn__25, - qpIn__26, - qpIn__27, - qpIn__28, - qpIn__29, - qpIn__3, - qpIn__30, - qpIn__31, - qpIn__32, - qpIn__33, - qpIn__34, - qpIn__35, - qpIn__36, - qpIn__37, - qpIn__38, - qpIn__39, - qpIn__4, - qpIn__5, - qpIn__6, - qpIn__7, - qpIn__8, - qpIn__9, - qpOut__0, - qpOut__1, - qpOut__10, - qpOut__11, - qpOut__12, - qpOut__13, - qpOut__14, - qpOut__15, - qpOut__16, - qpOut__17, - qpOut__18, - qpOut__19, - qpOut__2, - qpOut__3, - qpOut__4, - qpOut__5, - qpOut__6, - qpOut__7, - qpOut__8, - qpOut__9, - qpStruct__0, - qpStruct__1, - qpStruct__2, - ramp, - rdaeIn__0, - rdaeIn__1, - rdaeIn__10, - rdaeIn__11, - rdaeIn__12, - rdaeIn__13, - rdaeIn__14, - rdaeIn__15, - rdaeIn__16, - rdaeIn__17, - rdaeIn__18, - rdaeIn__19, - rdaeIn__2, - rdaeIn__20, - rdaeIn__21, - rdaeIn__22, - rdaeIn__23, - rdaeIn__24, - rdaeIn__25, - rdaeIn__26, - rdaeIn__27, - rdaeIn__28, - rdaeIn__29, - rdaeIn__3, - rdaeIn__30, - rdaeIn__31, - rdaeIn__4, - rdaeIn__5, - rdaeIn__6, - rdaeIn__7, - rdaeIn__8, - rdaeIn__9, - rdaeOut__0, - rdaeOut__1, - rdaeOut__10, - rdaeOut__11, - rdaeOut__12, - rdaeOut__13, - rdaeOut__14, - rdaeOut__15, - rdaeOut__2, - rdaeOut__3, - rdaeOut__4, - rdaeOut__5, - rdaeOut__6, - rdaeOut__7, - rdaeOut__8, - rdaeOut__9, - rectangle, - sdpIn__0, - sdpIn__1, - sdpIn__10, - sdpIn__11, - sdpIn__12, - sdpIn__13, - sdpIn__14, - sdpIn__15, - sdpIn__16, - sdpIn__17, - sdpIn__18, - sdpIn__19, - sdpIn__2, - sdpIn__20, - sdpIn__21, - sdpIn__22, - sdpIn__23, - sdpIn__24, - sdpIn__25, - sdpIn__26, - sdpIn__27, - sdpIn__28, - sdpIn__29, - sdpIn__3, - sdpIn__30, - sdpIn__31, - sdpIn__32, - sdpIn__33, - sdpIn__34, - sdpIn__35, - sdpIn__4, - sdpIn__5, - sdpIn__6, - sdpIn__7, - sdpIn__8, - sdpIn__9, - sdpOut__0, - sdpOut__1, - sdpOut__10, - sdpOut__11, - sdpOut__12, - sdpOut__13, - sdpOut__14, - sdpOut__15, - sdpOut__16, - sdpOut__17, - sdpOut__18, - sdpOut__19, - sdpOut__2, - sdpOut__20, - sdpOut__21, - sdpOut__22, - sdpOut__23, - sdpOut__24, - sdpOut__25, - sdpOut__26, - sdpOut__27, - sdpOut__28, - sdpOut__29, - sdpOut__3, - sdpOut__30, - sdpOut__31, - sdpOut__4, - sdpOut__5, - sdpOut__6, - sdpOut__7, - sdpOut__8, - sdpOut__9, - sdpStruct__0, - sdpStruct__1, - sdpStruct__2, - sdpStruct__3, - sdqpIn__0, - sdqpIn__1, - sdqpIn__10, - sdqpIn__11, - sdqpIn__12, - sdqpIn__13, - sdqpIn__14, - sdqpIn__15, - sdqpIn__16, - sdqpIn__17, - sdqpIn__18, - sdqpIn__19, - sdqpIn__2, - sdqpIn__20, - sdqpIn__21, - sdqpIn__22, - sdqpIn__23, - sdqpIn__24, - sdqpIn__25, - sdqpIn__26, - sdqpIn__27, - sdqpIn__28, - sdqpIn__29, - sdqpIn__3, - sdqpIn__30, - sdqpIn__31, - sdqpIn__32, - sdqpIn__33, - sdqpIn__34, - sdqpIn__35, - sdqpIn__36, - sdqpIn__37, - sdqpIn__38, - sdqpIn__39, - sdqpIn__4, - sdqpIn__5, - sdqpIn__6, - sdqpIn__7, - sdqpIn__8, - sdqpIn__9, - sdqpOut__0, - sdqpOut__1, - sdqpOut__10, - sdqpOut__11, - sdqpOut__12, - sdqpOut__13, - sdqpOut__14, - sdqpOut__15, - sdqpOut__16, - sdqpOut__17, - sdqpOut__18, - sdqpOut__19, - sdqpOut__2, - sdqpOut__20, - sdqpOut__21, - sdqpOut__22, - sdqpOut__23, - sdqpOut__24, - sdqpOut__25, - sdqpOut__26, - sdqpOut__27, - sdqpOut__28, - sdqpOut__29, - sdqpOut__3, - sdqpOut__30, - sdqpOut__31, - sdqpOut__4, - sdqpOut__5, - sdqpOut__6, - sdqpOut__7, - sdqpOut__8, - sdqpOut__9, - sdqpStruct__0, - sdqpStruct__1, - sdqpStruct__2, - sdqpStruct__3, - sdqpStruct__4, - simpleIRK__0, - simpleIRK__1, - simpleIRK__2, - simpleIRK__3, - simpleIRK__4, - simpleIntegrator__0, - simpleIntegrator__1, - simpleRK__0, - simpleRK__1, - simpleRK__2, - socpIn__0, - socpIn__1, - socpIn__10, - socpIn__11, - socpIn__12, - socpIn__13, - socpIn__14, - socpIn__15, - socpIn__16, - socpIn__17, - socpIn__18, - socpIn__19, - socpIn__2, - socpIn__20, - socpIn__21, - socpIn__22, - socpIn__23, - socpIn__24, - socpIn__25, - socpIn__26, - socpIn__27, - socpIn__28, - socpIn__29, - socpIn__3, - socpIn__30, - socpIn__31, - socpIn__32, - socpIn__33, - socpIn__34, - socpIn__35, - socpIn__36, - socpIn__37, - socpIn__38, - socpIn__39, - socpIn__4, - socpIn__40, - socpIn__41, - socpIn__42, - socpIn__43, - socpIn__5, - socpIn__6, - socpIn__7, - socpIn__8, - socpIn__9, - socpOut__0, - socpOut__1, - socpOut__10, - socpOut__11, - socpOut__12, - socpOut__13, - socpOut__14, - socpOut__15, - socpOut__16, - socpOut__17, - socpOut__18, - socpOut__19, - socpOut__2, - socpOut__20, - socpOut__21, - socpOut__22, - socpOut__23, - socpOut__24, - socpOut__25, - socpOut__26, - socpOut__27, - socpOut__3, - socpOut__4, - socpOut__5, - socpOut__6, - socpOut__7, - socpOut__8, - socpOut__9, - socpStruct__0, - socpStruct__1, - socpStruct__2, - socpStruct__3, - solve__0, - solve__1, - solve__2, - solve__3, - solve__4, - solve__5, - spy, - stabilizedQpIn__0, - stabilizedQpIn__1, - stabilizedQpIn__10, - stabilizedQpIn__11, - stabilizedQpIn__12, - stabilizedQpIn__13, - stabilizedQpIn__14, - stabilizedQpIn__15, - stabilizedQpIn__16, - stabilizedQpIn__17, - stabilizedQpIn__18, - stabilizedQpIn__19, - stabilizedQpIn__2, - stabilizedQpIn__20, - stabilizedQpIn__21, - stabilizedQpIn__22, - stabilizedQpIn__23, - stabilizedQpIn__24, - stabilizedQpIn__25, - stabilizedQpIn__26, - stabilizedQpIn__27, - stabilizedQpIn__28, - stabilizedQpIn__29, - stabilizedQpIn__3, - stabilizedQpIn__30, - stabilizedQpIn__31, - stabilizedQpIn__32, - stabilizedQpIn__33, - stabilizedQpIn__34, - stabilizedQpIn__35, - stabilizedQpIn__36, - stabilizedQpIn__37, - stabilizedQpIn__38, - stabilizedQpIn__39, - stabilizedQpIn__4, - stabilizedQpIn__40, - stabilizedQpIn__41, - stabilizedQpIn__42, - stabilizedQpIn__43, - stabilizedQpIn__44, - stabilizedQpIn__45, - stabilizedQpIn__46, - stabilizedQpIn__47, - stabilizedQpIn__48, - stabilizedQpIn__49, - stabilizedQpIn__5, - stabilizedQpIn__50, - stabilizedQpIn__51, - stabilizedQpIn__6, - stabilizedQpIn__7, - stabilizedQpIn__8, - stabilizedQpIn__9, - substituteInPlace__0, - substituteInPlace__1, - substituteInPlace__2, - substituteInPlace__3, - substituteInPlace__4, - substituteInPlace__5, - substituteInPlace__6, - substituteInPlace__7, - substituteInPlace__8, - substituteInPlace__9, - substitute__0, - substitute__1, - substitute__2, - substitute__3, - tangent__0, - tangent__1, - taylor__0, - taylor__1, - taylor__2, - triangle, - ) where - - -import Data.Vector ( Vector ) -import Foreign.C.Types -import Foreign.Marshal ( new, free ) -import Foreign.Storable ( peek ) -import Foreign.Ptr ( Ptr, nullPtr ) - -import Casadi.Core.Data -import Casadi.Core.Enums -import Casadi.Internal.CToolsInstances ( ) -import Casadi.Internal.FormatException ( formatException ) -import Casadi.Internal.MarshalTypes ( StdVec, StdString ) -import Casadi.Internal.Marshal ( withMarshal ) -import Casadi.Internal.WrapReturn ( WrapReturn(..) ) -foreign import ccall unsafe "cleIn__0" c_cleIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -cleIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__1" c_cleIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -cleIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__2" c_cleIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -cleIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__3" c_cleIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -cleIn__3 - :: Vector DMatrix -> IO (Vector DMatrix) -cleIn__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__4" c_cleIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -cleIn__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -cleIn__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__5" c_cleIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -cleIn__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -cleIn__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__6" c_cleIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -cleIn__6 - :: Vector MX -> IO (Vector MX) -cleIn__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__7" c_cleIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -cleIn__7 - :: Vector MX -> String -> IO (Vector MX) -cleIn__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__8" c_cleIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -cleIn__8 - :: Vector MX -> String -> String -> IO (Vector MX) -cleIn__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__9" c_cleIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -cleIn__9 - :: Vector SX -> IO (Vector SX) -cleIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__10" c_cleIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -cleIn__10 - :: Vector SX -> String -> IO (Vector SX) -cleIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleIn__11" c_cleIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -cleIn__11 - :: Vector SX -> String -> String -> IO (Vector SX) -cleIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__0" c_cleOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -cleOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__1" c_cleOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -cleOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__2" c_cleOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -cleOut__2 - :: Vector DMatrix -> IO (Vector DMatrix) -cleOut__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__3" c_cleOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -cleOut__3 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -cleOut__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__4" c_cleOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -cleOut__4 - :: Vector MX -> IO (Vector MX) -cleOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__5" c_cleOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -cleOut__5 - :: Vector MX -> String -> IO (Vector MX) -cleOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__6" c_cleOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -cleOut__6 - :: Vector SX -> IO (Vector SX) -cleOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleOut__7" c_cleOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -cleOut__7 - :: Vector SX -> String -> IO (Vector SX) -cleOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleStruct__0" c_cleStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -cleStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleStruct__1" c_cleStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -cleStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleStruct__2" c_cleStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -cleStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "cleStruct__3" c_cleStruct__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -cleStruct__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -cleStruct__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_cleStruct__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "collocationPoints__0" c_collocationPoints__0 - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec CDouble)) -collocationPoints__0 - :: Int -> IO (Vector Double) -collocationPoints__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_collocationPoints__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "collocationPoints__1" c_collocationPoints__1 - :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO (Ptr (StdVec CDouble)) -collocationPoints__1 - :: Int -> String -> IO (Vector Double) -collocationPoints__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_collocationPoints__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "complement" c_complement - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) -complement - :: Vector Int -> Int -> IO (Vector Int) -complement x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_complement errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__0" c_controldaeIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -controldaeIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__1" c_controldaeIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -controldaeIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__2" c_controldaeIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -controldaeIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__3" c_controldaeIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -controldaeIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__4" c_controldaeIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -controldaeIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__5" c_controldaeIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -controldaeIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__6" c_controldaeIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -controldaeIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__7" c_controldaeIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -controldaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__8" c_controldaeIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -controldaeIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__9" c_controldaeIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controldaeIn__9 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -controldaeIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__10" c_controldaeIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__10 - :: Vector DMatrix -> IO (Vector DMatrix) -controldaeIn__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__11" c_controldaeIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__11 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -controldaeIn__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__12" c_controldaeIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__12 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -controldaeIn__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__13" c_controldaeIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__13 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -controldaeIn__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__14" c_controldaeIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__14 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -controldaeIn__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__15" c_controldaeIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -controldaeIn__15 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__16" c_controldaeIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__16 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -controldaeIn__16 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__17" c_controldaeIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -controldaeIn__17 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__18" c_controldaeIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__18 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -controldaeIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__19" c_controldaeIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controldaeIn__19 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -controldaeIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__20" c_controldaeIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__20 - :: Vector MX -> IO (Vector MX) -controldaeIn__20 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__20 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__21" c_controldaeIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__21 - :: Vector MX -> String -> IO (Vector MX) -controldaeIn__21 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__21 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__22" c_controldaeIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__22 - :: Vector MX -> String -> String -> IO (Vector MX) -controldaeIn__22 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__22 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__23" c_controldaeIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__23 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -controldaeIn__23 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__23 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__24" c_controldaeIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__24 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -controldaeIn__24 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__24 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__25" c_controldaeIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__25 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -controldaeIn__25 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__26" c_controldaeIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__26 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -controldaeIn__26 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__27" c_controldaeIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__27 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -controldaeIn__27 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__28" c_controldaeIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__28 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -controldaeIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__29" c_controldaeIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controldaeIn__29 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -controldaeIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__30" c_controldaeIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__30 - :: Vector SX -> IO (Vector SX) -controldaeIn__30 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__30 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__31" c_controldaeIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__31 - :: Vector SX -> String -> IO (Vector SX) -controldaeIn__31 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__31 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__32" c_controldaeIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__32 - :: Vector SX -> String -> String -> IO (Vector SX) -controldaeIn__32 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__32 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__33" c_controldaeIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__33 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -controldaeIn__33 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__33 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__34" c_controldaeIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__34 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -controldaeIn__34 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__34 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__35" c_controldaeIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__35 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -controldaeIn__35 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__36" c_controldaeIn__36 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__36 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -controldaeIn__36 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__37" c_controldaeIn__37 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__37 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -controldaeIn__37 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__38" c_controldaeIn__38 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__38 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -controldaeIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controldaeIn__39" c_controldaeIn__39 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controldaeIn__39 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -controldaeIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_controldaeIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__0" c_controlsimulatorIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -controlsimulatorIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -controlsimulatorIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__1" c_controlsimulatorIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controlsimulatorIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -controlsimulatorIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__2" c_controlsimulatorIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controlsimulatorIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -controlsimulatorIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__3" c_controlsimulatorIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -controlsimulatorIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -controlsimulatorIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__4" c_controlsimulatorIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -controlsimulatorIn__4 - :: Vector DMatrix -> IO (Vector DMatrix) -controlsimulatorIn__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__5" c_controlsimulatorIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controlsimulatorIn__5 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -controlsimulatorIn__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__6" c_controlsimulatorIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controlsimulatorIn__6 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -controlsimulatorIn__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__7" c_controlsimulatorIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -controlsimulatorIn__7 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -controlsimulatorIn__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__8" c_controlsimulatorIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -controlsimulatorIn__8 - :: Vector MX -> IO (Vector MX) -controlsimulatorIn__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__9" c_controlsimulatorIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controlsimulatorIn__9 - :: Vector MX -> String -> IO (Vector MX) -controlsimulatorIn__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__10" c_controlsimulatorIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controlsimulatorIn__10 - :: Vector MX -> String -> String -> IO (Vector MX) -controlsimulatorIn__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__11" c_controlsimulatorIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -controlsimulatorIn__11 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -controlsimulatorIn__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__12" c_controlsimulatorIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -controlsimulatorIn__12 - :: Vector SX -> IO (Vector SX) -controlsimulatorIn__12 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__12 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__13" c_controlsimulatorIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controlsimulatorIn__13 - :: Vector SX -> String -> IO (Vector SX) -controlsimulatorIn__13 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__13 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__14" c_controlsimulatorIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controlsimulatorIn__14 - :: Vector SX -> String -> String -> IO (Vector SX) -controlsimulatorIn__14 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__14 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "controlsimulatorIn__15" c_controlsimulatorIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -controlsimulatorIn__15 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -controlsimulatorIn__15 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_controlsimulatorIn__15 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "countNodes__0" c_countNodes__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt -countNodes__0 - :: MX -> IO Int -countNodes__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_countNodes__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "countNodes__1" c_countNodes__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt -countNodes__1 - :: SX -> IO Int -countNodes__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_countNodes__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "createParent__0" c_createParent__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -createParent__0 - :: Vector Sparsity -> Vector MX -> IO MX -createParent__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_createParent__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "createParent__1" c_createParent__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -createParent__1 - :: Vector MX -> Vector MX -> IO MX -createParent__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_createParent__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "createParent__2" c_createParent__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -createParent__2 - :: Vector MX -> IO MX -createParent__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_createParent__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__0" c_daeIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -daeIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__1" c_daeIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -daeIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__2" c_daeIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -daeIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__3" c_daeIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -daeIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__4" c_daeIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -daeIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__5" c_daeIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeIn__5 - :: Vector DMatrix -> IO (Vector DMatrix) -daeIn__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__6" c_daeIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeIn__6 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -daeIn__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__7" c_daeIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeIn__7 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -daeIn__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__8" c_daeIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeIn__8 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -daeIn__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__9" c_daeIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeIn__9 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -daeIn__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__10" c_daeIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -daeIn__10 - :: Vector MX -> IO (Vector MX) -daeIn__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__11" c_daeIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -daeIn__11 - :: Vector MX -> String -> IO (Vector MX) -daeIn__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__12" c_daeIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -daeIn__12 - :: Vector MX -> String -> String -> IO (Vector MX) -daeIn__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__13" c_daeIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -daeIn__13 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -daeIn__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__14" c_daeIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -daeIn__14 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -daeIn__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__15" c_daeIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -daeIn__15 - :: Vector SX -> IO (Vector SX) -daeIn__15 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__15 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__16" c_daeIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -daeIn__16 - :: Vector SX -> String -> IO (Vector SX) -daeIn__16 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__16 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__17" c_daeIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -daeIn__17 - :: Vector SX -> String -> String -> IO (Vector SX) -daeIn__17 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__17 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__18" c_daeIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -daeIn__18 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -daeIn__18 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__18 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeIn__19" c_daeIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -daeIn__19 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -daeIn__19 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeIn__19 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__0" c_daeOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -daeOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__1" c_daeOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -daeOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__2" c_daeOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -daeOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__3" c_daeOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -daeOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -daeOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__4" c_daeOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeOut__4 - :: Vector DMatrix -> IO (Vector DMatrix) -daeOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__5" c_daeOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeOut__5 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -daeOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__6" c_daeOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeOut__6 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -daeOut__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__7" c_daeOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -daeOut__7 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -daeOut__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__8" c_daeOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -daeOut__8 - :: Vector MX -> IO (Vector MX) -daeOut__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__9" c_daeOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -daeOut__9 - :: Vector MX -> String -> IO (Vector MX) -daeOut__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__10" c_daeOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -daeOut__10 - :: Vector MX -> String -> String -> IO (Vector MX) -daeOut__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__11" c_daeOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -daeOut__11 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -daeOut__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__12" c_daeOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -daeOut__12 - :: Vector SX -> IO (Vector SX) -daeOut__12 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__12 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__13" c_daeOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -daeOut__13 - :: Vector SX -> String -> IO (Vector SX) -daeOut__13 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__13 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__14" c_daeOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -daeOut__14 - :: Vector SX -> String -> String -> IO (Vector SX) -daeOut__14 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__14 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "daeOut__15" c_daeOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -daeOut__15 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -daeOut__15 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_daeOut__15 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dependsOn__0" c_dependsOn__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO CInt -dependsOn__0 - :: MX -> Vector MX -> IO Bool -dependsOn__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dependsOn__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dependsOn__1" c_dependsOn__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt -dependsOn__1 - :: SX -> SX -> IO Bool -dependsOn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dependsOn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__0" c_dleIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -dleIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__1" c_dleIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -dleIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__2" c_dleIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -dleIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__3" c_dleIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -dleIn__3 - :: Vector DMatrix -> IO (Vector DMatrix) -dleIn__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__4" c_dleIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -dleIn__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -dleIn__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__5" c_dleIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -dleIn__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -dleIn__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__6" c_dleIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -dleIn__6 - :: Vector MX -> IO (Vector MX) -dleIn__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__7" c_dleIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -dleIn__7 - :: Vector MX -> String -> IO (Vector MX) -dleIn__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__8" c_dleIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -dleIn__8 - :: Vector MX -> String -> String -> IO (Vector MX) -dleIn__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__9" c_dleIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -dleIn__9 - :: Vector SX -> IO (Vector SX) -dleIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__10" c_dleIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -dleIn__10 - :: Vector SX -> String -> IO (Vector SX) -dleIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleIn__11" c_dleIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -dleIn__11 - :: Vector SX -> String -> String -> IO (Vector SX) -dleIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__0" c_dleOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -dleOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__1" c_dleOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -dleOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__2" c_dleOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -dleOut__2 - :: Vector DMatrix -> IO (Vector DMatrix) -dleOut__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__3" c_dleOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -dleOut__3 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -dleOut__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__4" c_dleOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -dleOut__4 - :: Vector MX -> IO (Vector MX) -dleOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__5" c_dleOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -dleOut__5 - :: Vector MX -> String -> IO (Vector MX) -dleOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__6" c_dleOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -dleOut__6 - :: Vector SX -> IO (Vector SX) -dleOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleOut__7" c_dleOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -dleOut__7 - :: Vector SX -> String -> IO (Vector SX) -dleOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleStruct__0" c_dleStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -dleStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleStruct__1" c_dleStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -dleStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dleStruct__2" c_dleStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dleStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -dleStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dleStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__0" c_dpleIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -dpleIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -dpleIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__1" c_dpleIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dpleIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -dpleIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__2" c_dpleIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dpleIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -dpleIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__3" c_dpleIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -dpleIn__3 - :: Vector DMatrix -> IO (Vector DMatrix) -dpleIn__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__4" c_dpleIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -dpleIn__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -dpleIn__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__5" c_dpleIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -dpleIn__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -dpleIn__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__6" c_dpleIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -dpleIn__6 - :: Vector MX -> IO (Vector MX) -dpleIn__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__7" c_dpleIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -dpleIn__7 - :: Vector MX -> String -> IO (Vector MX) -dpleIn__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__8" c_dpleIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -dpleIn__8 - :: Vector MX -> String -> String -> IO (Vector MX) -dpleIn__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__9" c_dpleIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -dpleIn__9 - :: Vector SX -> IO (Vector SX) -dpleIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__10" c_dpleIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -dpleIn__10 - :: Vector SX -> String -> IO (Vector SX) -dpleIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleIn__11" c_dpleIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -dpleIn__11 - :: Vector SX -> String -> String -> IO (Vector SX) -dpleIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__0" c_dpleOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -dpleOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -dpleOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__1" c_dpleOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -dpleOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -dpleOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__2" c_dpleOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -dpleOut__2 - :: Vector DMatrix -> IO (Vector DMatrix) -dpleOut__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__3" c_dpleOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -dpleOut__3 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -dpleOut__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__4" c_dpleOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -dpleOut__4 - :: Vector MX -> IO (Vector MX) -dpleOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__5" c_dpleOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -dpleOut__5 - :: Vector MX -> String -> IO (Vector MX) -dpleOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__6" c_dpleOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -dpleOut__6 - :: Vector SX -> IO (Vector SX) -dpleOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleOut__7" c_dpleOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -dpleOut__7 - :: Vector SX -> String -> IO (Vector SX) -dpleOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleStruct__0" c_dpleStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -dpleStruct__0 - :: Vector (Vector Sparsity) -> IO (Vector (Vector Sparsity)) -dpleStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleStruct__1" c_dpleStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -dpleStruct__1 - :: Vector (Vector Sparsity) -> String -> IO (Vector (Vector Sparsity)) -dpleStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "dpleStruct__2" c_dpleStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -dpleStruct__2 - :: Vector (Vector Sparsity) -> String -> String -> IO (Vector (Vector Sparsity)) -dpleStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_dpleStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "eig_symbolic" c_eig_symbolic - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -eig_symbolic - :: SX -> IO SX -eig_symbolic x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_eig_symbolic errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "evalf__0" c_evalf__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr DMatrix' -> IO (Ptr DMatrix') -evalf__0 - :: SX -> SX -> DMatrix -> IO DMatrix -evalf__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_evalf__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "evalf__1" c_evalf__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr DMatrix') -evalf__1 - :: SX -> IO DMatrix -evalf__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_evalf__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "expand" c_expand - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () -expand - :: SX -> SX -> SX -> IO () -expand x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_expand errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "extractShared__0" c_extractShared__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () -extractShared__0 - :: Vector MX -> Vector MX -> Vector MX -> IO () -extractShared__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_extractShared__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "extractShared__1" c_extractShared__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO () -extractShared__1 - :: Vector MX -> Vector MX -> Vector MX -> String -> IO () -extractShared__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_extractShared__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "extractShared__2" c_extractShared__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO () -extractShared__2 - :: Vector MX -> Vector MX -> Vector MX -> String -> String -> IO () -extractShared__2 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "extractShared__3" c_extractShared__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () -extractShared__3 - :: Vector SX -> Vector SX -> Vector SX -> IO () -extractShared__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_extractShared__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "extractShared__4" c_extractShared__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO () -extractShared__4 - :: Vector SX -> Vector SX -> Vector SX -> String -> IO () -extractShared__4 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_extractShared__4 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "extractShared__5" c_extractShared__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO () -extractShared__5 - :: Vector SX -> Vector SX -> Vector SX -> String -> String -> IO () -extractShared__5 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_extractShared__5 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gauss_quadrature__0" c_gauss_quadrature__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -gauss_quadrature__0 - :: SX -> SX -> SX -> SX -> IO SX -gauss_quadrature__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gauss_quadrature__1" c_gauss_quadrature__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -gauss_quadrature__1 - :: SX -> SX -> SX -> SX -> Int -> IO SX -gauss_quadrature__1 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gauss_quadrature__2" c_gauss_quadrature__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr SX' -> IO (Ptr SX') -gauss_quadrature__2 - :: SX -> SX -> SX -> SX -> Int -> SX -> IO SX -gauss_quadrature__2 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getFree" c_getFree - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -getFree - :: SX -> IO SX -getFree x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_getFree errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getOperatorRepresentation__0" c_getOperatorRepresentation__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) -getOperatorRepresentation__0 - :: MX -> Vector String -> IO String -getOperatorRepresentation__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_getOperatorRepresentation__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getOperatorRepresentation__1" c_getOperatorRepresentation__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) -getOperatorRepresentation__1 - :: SX -> Vector String -> IO String -getOperatorRepresentation__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_getOperatorRepresentation__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSchemeEntryDoc" c_getSchemeEntryDoc - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString) -getSchemeEntryDoc - :: InputOutputScheme -> Int -> IO String -getSchemeEntryDoc x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSchemeEntryDoc errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSchemeEntryEnum" c_getSchemeEntryEnum - :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO CInt -getSchemeEntryEnum - :: InputOutputScheme -> String -> IO Int -getSchemeEntryEnum x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSchemeEntryEnum errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSchemeEntryEnumName" c_getSchemeEntryEnumName - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString) -getSchemeEntryEnumName - :: InputOutputScheme -> Int -> IO String -getSchemeEntryEnumName x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSchemeEntryEnumName errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSchemeEntryName" c_getSchemeEntryName - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString) -getSchemeEntryName - :: InputOutputScheme -> Int -> IO String -getSchemeEntryName x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSchemeEntryName errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSchemeEntryNames" c_getSchemeEntryNames - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString) -getSchemeEntryNames - :: InputOutputScheme -> IO String -getSchemeEntryNames x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSchemeEntryNames errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSchemeName" c_getSchemeName - :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString) -getSchemeName - :: InputOutputScheme -> IO String -getSchemeName x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSchemeName errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSchemeSize" c_getSchemeSize - :: Ptr (Ptr StdString) -> CInt -> IO CInt -getSchemeSize - :: InputOutputScheme -> IO Int -getSchemeSize x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSchemeSize errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSymbols__0" c_getSymbols__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -getSymbols__0 - :: Vector MX -> IO (Vector MX) -getSymbols__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSymbols__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSymbols__1" c_getSymbols__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) -getSymbols__1 - :: MX -> IO (Vector MX) -getSymbols__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSymbols__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "getSymbols__2" c_getSymbols__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -getSymbols__2 - :: SX -> IO SX -getSymbols__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_getSymbols__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__0" c_gradFIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -gradFIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -gradFIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__1" c_gradFIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -gradFIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -gradFIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__2" c_gradFIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -gradFIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -gradFIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__3" c_gradFIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -gradFIn__3 - :: Vector DMatrix -> IO (Vector DMatrix) -gradFIn__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__4" c_gradFIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -gradFIn__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -gradFIn__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__5" c_gradFIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -gradFIn__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -gradFIn__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__6" c_gradFIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -gradFIn__6 - :: Vector MX -> IO (Vector MX) -gradFIn__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__7" c_gradFIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -gradFIn__7 - :: Vector MX -> String -> IO (Vector MX) -gradFIn__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__8" c_gradFIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -gradFIn__8 - :: Vector MX -> String -> String -> IO (Vector MX) -gradFIn__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__9" c_gradFIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -gradFIn__9 - :: Vector SX -> IO (Vector SX) -gradFIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__10" c_gradFIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -gradFIn__10 - :: Vector SX -> String -> IO (Vector SX) -gradFIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFIn__11" c_gradFIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -gradFIn__11 - :: Vector SX -> String -> String -> IO (Vector SX) -gradFIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__0" c_gradFOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -gradFOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -gradFOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__1" c_gradFOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -gradFOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -gradFOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__2" c_gradFOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -gradFOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -gradFOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__3" c_gradFOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -gradFOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -gradFOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__4" c_gradFOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -gradFOut__4 - :: Vector DMatrix -> IO (Vector DMatrix) -gradFOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__5" c_gradFOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -gradFOut__5 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -gradFOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__6" c_gradFOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -gradFOut__6 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -gradFOut__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__7" c_gradFOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -gradFOut__7 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -gradFOut__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__8" c_gradFOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -gradFOut__8 - :: Vector MX -> IO (Vector MX) -gradFOut__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__9" c_gradFOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -gradFOut__9 - :: Vector MX -> String -> IO (Vector MX) -gradFOut__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__10" c_gradFOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -gradFOut__10 - :: Vector MX -> String -> String -> IO (Vector MX) -gradFOut__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__11" c_gradFOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -gradFOut__11 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -gradFOut__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__12" c_gradFOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -gradFOut__12 - :: Vector SX -> IO (Vector SX) -gradFOut__12 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__12 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__13" c_gradFOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -gradFOut__13 - :: Vector SX -> String -> IO (Vector SX) -gradFOut__13 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__13 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__14" c_gradFOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -gradFOut__14 - :: Vector SX -> String -> String -> IO (Vector SX) -gradFOut__14 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__14 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradFOut__15" c_gradFOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -gradFOut__15 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -gradFOut__15 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradFOut__15 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradient__0" c_gradient__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -gradient__0 - :: MX -> MX -> IO MX -gradient__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradient__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "gradient__1" c_gradient__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -gradient__1 - :: SX -> SX -> IO SX -gradient__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_gradient__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "graph_substitute__0" c_graph_substitute__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -graph_substitute__0 - :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) -graph_substitute__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_graph_substitute__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "graph_substitute__1" c_graph_substitute__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -graph_substitute__1 - :: MX -> Vector MX -> Vector MX -> IO MX -graph_substitute__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_graph_substitute__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "heaviside" c_heaviside - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -heaviside - :: SX -> IO SX -heaviside x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_heaviside errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__0" c_hessLagIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -hessLagIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__1" c_hessLagIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -hessLagIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__2" c_hessLagIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -hessLagIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__3" c_hessLagIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -hessLagIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__4" c_hessLagIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -hessLagIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__5" c_hessLagIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagIn__5 - :: Vector DMatrix -> IO (Vector DMatrix) -hessLagIn__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__6" c_hessLagIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagIn__6 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -hessLagIn__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__7" c_hessLagIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagIn__7 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -hessLagIn__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__8" c_hessLagIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagIn__8 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -hessLagIn__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__9" c_hessLagIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagIn__9 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -hessLagIn__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__10" c_hessLagIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -hessLagIn__10 - :: Vector MX -> IO (Vector MX) -hessLagIn__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__11" c_hessLagIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagIn__11 - :: Vector MX -> String -> IO (Vector MX) -hessLagIn__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__12" c_hessLagIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagIn__12 - :: Vector MX -> String -> String -> IO (Vector MX) -hessLagIn__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__13" c_hessLagIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagIn__13 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -hessLagIn__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__14" c_hessLagIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagIn__14 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -hessLagIn__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__15" c_hessLagIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -hessLagIn__15 - :: Vector SX -> IO (Vector SX) -hessLagIn__15 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__15 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__16" c_hessLagIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagIn__16 - :: Vector SX -> String -> IO (Vector SX) -hessLagIn__16 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__16 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__17" c_hessLagIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagIn__17 - :: Vector SX -> String -> String -> IO (Vector SX) -hessLagIn__17 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__17 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__18" c_hessLagIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagIn__18 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -hessLagIn__18 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__18 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagIn__19" c_hessLagIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagIn__19 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -hessLagIn__19 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagIn__19 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__0" c_hessLagOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -hessLagOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__1" c_hessLagOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -hessLagOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__2" c_hessLagOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -hessLagOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__3" c_hessLagOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -hessLagOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__4" c_hessLagOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -hessLagOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__5" c_hessLagOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hessLagOut__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -hessLagOut__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__6" c_hessLagOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagOut__6 - :: Vector DMatrix -> IO (Vector DMatrix) -hessLagOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__7" c_hessLagOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagOut__7 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -hessLagOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__8" c_hessLagOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagOut__8 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -hessLagOut__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__9" c_hessLagOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagOut__9 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -hessLagOut__9 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__9 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__10" c_hessLagOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagOut__10 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -hessLagOut__10 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__10 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__11" c_hessLagOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hessLagOut__11 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -hessLagOut__11 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__12" c_hessLagOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -hessLagOut__12 - :: Vector MX -> IO (Vector MX) -hessLagOut__12 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__12 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__13" c_hessLagOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagOut__13 - :: Vector MX -> String -> IO (Vector MX) -hessLagOut__13 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__13 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__14" c_hessLagOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagOut__14 - :: Vector MX -> String -> String -> IO (Vector MX) -hessLagOut__14 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__14 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__15" c_hessLagOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagOut__15 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -hessLagOut__15 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__15 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__16" c_hessLagOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagOut__16 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -hessLagOut__16 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__16 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__17" c_hessLagOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hessLagOut__17 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -hessLagOut__17 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__18" c_hessLagOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -hessLagOut__18 - :: Vector SX -> IO (Vector SX) -hessLagOut__18 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__18 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__19" c_hessLagOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagOut__19 - :: Vector SX -> String -> IO (Vector SX) -hessLagOut__19 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__19 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__20" c_hessLagOut__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagOut__20 - :: Vector SX -> String -> String -> IO (Vector SX) -hessLagOut__20 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__20 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__21" c_hessLagOut__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagOut__21 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -hessLagOut__21 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__21 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__22" c_hessLagOut__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagOut__22 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -hessLagOut__22 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__22 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessLagOut__23" c_hessLagOut__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hessLagOut__23 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -hessLagOut__23 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessLagOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessian__0" c_hessian__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO () -hessian__0 - :: MX -> MX -> MX -> MX -> IO () -hessian__0 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessian__0 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessian__1" c_hessian__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -hessian__1 - :: MX -> MX -> IO MX -hessian__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessian__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessian__2" c_hessian__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () -hessian__2 - :: SX -> SX -> SX -> SX -> IO () -hessian__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessian__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hessian__3" c_hessian__3 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -hessian__3 - :: SX -> SX -> IO SX -hessian__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hessian__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__0" c_hnlpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -hnlpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -hnlpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__1" c_hnlpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hnlpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -hnlpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__2" c_hnlpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hnlpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -hnlpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__3" c_hnlpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -hnlpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -hnlpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__4" c_hnlpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -hnlpIn__4 - :: Vector DMatrix -> IO (Vector DMatrix) -hnlpIn__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__5" c_hnlpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hnlpIn__5 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -hnlpIn__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__6" c_hnlpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hnlpIn__6 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -hnlpIn__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__7" c_hnlpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -hnlpIn__7 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -hnlpIn__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__8" c_hnlpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -hnlpIn__8 - :: Vector MX -> IO (Vector MX) -hnlpIn__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__9" c_hnlpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hnlpIn__9 - :: Vector MX -> String -> IO (Vector MX) -hnlpIn__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__10" c_hnlpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hnlpIn__10 - :: Vector MX -> String -> String -> IO (Vector MX) -hnlpIn__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__11" c_hnlpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -hnlpIn__11 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -hnlpIn__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__12" c_hnlpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -hnlpIn__12 - :: Vector SX -> IO (Vector SX) -hnlpIn__12 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__12 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__13" c_hnlpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hnlpIn__13 - :: Vector SX -> String -> IO (Vector SX) -hnlpIn__13 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__13 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__14" c_hnlpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hnlpIn__14 - :: Vector SX -> String -> String -> IO (Vector SX) -hnlpIn__14 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__14 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "hnlpIn__15" c_hnlpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -hnlpIn__15 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -hnlpIn__15 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_hnlpIn__15 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__0" c_integratorIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -integratorIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__1" c_integratorIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -integratorIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__2" c_integratorIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -integratorIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__3" c_integratorIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -integratorIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__4" c_integratorIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -integratorIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__5" c_integratorIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -integratorIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__6" c_integratorIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -integratorIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__7" c_integratorIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorIn__7 - :: Vector DMatrix -> IO (Vector DMatrix) -integratorIn__7 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__7 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__8" c_integratorIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorIn__8 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -integratorIn__8 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__8 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__9" c_integratorIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorIn__9 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -integratorIn__9 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__9 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__10" c_integratorIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorIn__10 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -integratorIn__10 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__10 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__11" c_integratorIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorIn__11 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -integratorIn__11 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__11 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__12" c_integratorIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorIn__12 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -integratorIn__12 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__13" c_integratorIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorIn__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -integratorIn__13 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__14" c_integratorIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -integratorIn__14 - :: Vector MX -> IO (Vector MX) -integratorIn__14 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__14 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__15" c_integratorIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorIn__15 - :: Vector MX -> String -> IO (Vector MX) -integratorIn__15 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__15 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__16" c_integratorIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorIn__16 - :: Vector MX -> String -> String -> IO (Vector MX) -integratorIn__16 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__16 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__17" c_integratorIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorIn__17 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -integratorIn__17 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__17 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__18" c_integratorIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorIn__18 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -integratorIn__18 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__18 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__19" c_integratorIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorIn__19 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -integratorIn__19 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__20" c_integratorIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorIn__20 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -integratorIn__20 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__21" c_integratorIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -integratorIn__21 - :: Vector SX -> IO (Vector SX) -integratorIn__21 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__21 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__22" c_integratorIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorIn__22 - :: Vector SX -> String -> IO (Vector SX) -integratorIn__22 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__22 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__23" c_integratorIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorIn__23 - :: Vector SX -> String -> String -> IO (Vector SX) -integratorIn__23 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__23 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__24" c_integratorIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorIn__24 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -integratorIn__24 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__24 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__25" c_integratorIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorIn__25 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -integratorIn__25 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__25 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__26" c_integratorIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorIn__26 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -integratorIn__26 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorIn__27" c_integratorIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorIn__27 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -integratorIn__27 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__0" c_integratorOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -integratorOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__1" c_integratorOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -integratorOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__2" c_integratorOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -integratorOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__3" c_integratorOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -integratorOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__4" c_integratorOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -integratorOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__5" c_integratorOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorOut__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -integratorOut__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__6" c_integratorOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -integratorOut__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -integratorOut__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__7" c_integratorOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorOut__7 - :: Vector DMatrix -> IO (Vector DMatrix) -integratorOut__7 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__7 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__8" c_integratorOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorOut__8 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -integratorOut__8 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__8 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__9" c_integratorOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorOut__9 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -integratorOut__9 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__9 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__10" c_integratorOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorOut__10 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -integratorOut__10 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__10 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__11" c_integratorOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorOut__11 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -integratorOut__11 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__11 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__12" c_integratorOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorOut__12 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -integratorOut__12 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__13" c_integratorOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -integratorOut__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -integratorOut__13 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__14" c_integratorOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -integratorOut__14 - :: Vector MX -> IO (Vector MX) -integratorOut__14 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__14 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__15" c_integratorOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorOut__15 - :: Vector MX -> String -> IO (Vector MX) -integratorOut__15 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__15 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__16" c_integratorOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorOut__16 - :: Vector MX -> String -> String -> IO (Vector MX) -integratorOut__16 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__16 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__17" c_integratorOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorOut__17 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -integratorOut__17 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__17 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__18" c_integratorOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorOut__18 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -integratorOut__18 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__18 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__19" c_integratorOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorOut__19 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -integratorOut__19 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__20" c_integratorOut__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -integratorOut__20 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -integratorOut__20 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__21" c_integratorOut__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -integratorOut__21 - :: Vector SX -> IO (Vector SX) -integratorOut__21 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__21 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__22" c_integratorOut__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorOut__22 - :: Vector SX -> String -> IO (Vector SX) -integratorOut__22 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__22 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__23" c_integratorOut__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorOut__23 - :: Vector SX -> String -> String -> IO (Vector SX) -integratorOut__23 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__23 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__24" c_integratorOut__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorOut__24 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -integratorOut__24 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__24 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__25" c_integratorOut__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorOut__25 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -integratorOut__25 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__25 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__26" c_integratorOut__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorOut__26 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -integratorOut__26 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "integratorOut__27" c_integratorOut__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -integratorOut__27 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -integratorOut__27 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_integratorOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isDecreasing__0" c_isDecreasing__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt -isDecreasing__0 - :: Vector Double -> IO Bool -isDecreasing__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isDecreasing__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isDecreasing__1" c_isDecreasing__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt -isDecreasing__1 - :: Vector Int -> IO Bool -isDecreasing__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isDecreasing__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isIncreasing__0" c_isIncreasing__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt -isIncreasing__0 - :: Vector Double -> IO Bool -isIncreasing__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isIncreasing__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isIncreasing__1" c_isIncreasing__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt -isIncreasing__1 - :: Vector Int -> IO Bool -isIncreasing__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isIncreasing__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isMonotone__0" c_isMonotone__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt -isMonotone__0 - :: Vector Double -> IO Bool -isMonotone__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isMonotone__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isMonotone__1" c_isMonotone__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt -isMonotone__1 - :: Vector Int -> IO Bool -isMonotone__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isMonotone__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isNonDecreasing__0" c_isNonDecreasing__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt -isNonDecreasing__0 - :: Vector Double -> IO Bool -isNonDecreasing__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isNonDecreasing__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isNonDecreasing__1" c_isNonDecreasing__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt -isNonDecreasing__1 - :: Vector Int -> IO Bool -isNonDecreasing__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isNonDecreasing__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isNonIncreasing__0" c_isNonIncreasing__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt -isNonIncreasing__0 - :: Vector Double -> IO Bool -isNonIncreasing__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isNonIncreasing__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isNonIncreasing__1" c_isNonIncreasing__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt -isNonIncreasing__1 - :: Vector Int -> IO Bool -isNonIncreasing__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isNonIncreasing__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isRegular__0" c_isRegular__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt -isRegular__0 - :: Vector Double -> IO Bool -isRegular__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isRegular__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isRegular__1" c_isRegular__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt -isRegular__1 - :: Vector Int -> IO Bool -isRegular__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isRegular__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isStrictlyMonotone__0" c_isStrictlyMonotone__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> IO CInt -isStrictlyMonotone__0 - :: Vector Double -> IO Bool -isStrictlyMonotone__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isStrictlyMonotone__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "isStrictlyMonotone__1" c_isStrictlyMonotone__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> IO CInt -isStrictlyMonotone__1 - :: Vector Int -> IO Bool -isStrictlyMonotone__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_isStrictlyMonotone__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__0" c_jacGIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -jacGIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -jacGIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__1" c_jacGIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -jacGIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -jacGIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__2" c_jacGIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -jacGIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -jacGIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__3" c_jacGIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -jacGIn__3 - :: Vector DMatrix -> IO (Vector DMatrix) -jacGIn__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__4" c_jacGIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -jacGIn__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -jacGIn__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__5" c_jacGIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -jacGIn__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -jacGIn__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__6" c_jacGIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -jacGIn__6 - :: Vector MX -> IO (Vector MX) -jacGIn__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__7" c_jacGIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -jacGIn__7 - :: Vector MX -> String -> IO (Vector MX) -jacGIn__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__8" c_jacGIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -jacGIn__8 - :: Vector MX -> String -> String -> IO (Vector MX) -jacGIn__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__9" c_jacGIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -jacGIn__9 - :: Vector SX -> IO (Vector SX) -jacGIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__10" c_jacGIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -jacGIn__10 - :: Vector SX -> String -> IO (Vector SX) -jacGIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGIn__11" c_jacGIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -jacGIn__11 - :: Vector SX -> String -> String -> IO (Vector SX) -jacGIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__0" c_jacGOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -jacGOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -jacGOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__1" c_jacGOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -jacGOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -jacGOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__2" c_jacGOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -jacGOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -jacGOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__3" c_jacGOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -jacGOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -jacGOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__4" c_jacGOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -jacGOut__4 - :: Vector DMatrix -> IO (Vector DMatrix) -jacGOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__5" c_jacGOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -jacGOut__5 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -jacGOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__6" c_jacGOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -jacGOut__6 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -jacGOut__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__7" c_jacGOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -jacGOut__7 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -jacGOut__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__8" c_jacGOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -jacGOut__8 - :: Vector MX -> IO (Vector MX) -jacGOut__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__9" c_jacGOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -jacGOut__9 - :: Vector MX -> String -> IO (Vector MX) -jacGOut__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__10" c_jacGOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -jacGOut__10 - :: Vector MX -> String -> String -> IO (Vector MX) -jacGOut__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__11" c_jacGOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -jacGOut__11 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -jacGOut__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__12" c_jacGOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -jacGOut__12 - :: Vector SX -> IO (Vector SX) -jacGOut__12 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__12 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__13" c_jacGOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -jacGOut__13 - :: Vector SX -> String -> IO (Vector SX) -jacGOut__13 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__13 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__14" c_jacGOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -jacGOut__14 - :: Vector SX -> String -> String -> IO (Vector SX) -jacGOut__14 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__14 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacGOut__15" c_jacGOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -jacGOut__15 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -jacGOut__15 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacGOut__15 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacobian__0" c_jacobian__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -jacobian__0 - :: MX -> MX -> IO MX -jacobian__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacobian__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacobian__1" c_jacobian__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -jacobian__1 - :: SX -> SX -> IO SX -jacobian__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacobian__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacobianTimesVector__0" c_jacobianTimesVector__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -jacobianTimesVector__0 - :: SX -> SX -> SX -> IO SX -jacobianTimesVector__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacobianTimesVector__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "jacobianTimesVector__1" c_jacobianTimesVector__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -jacobianTimesVector__1 - :: SX -> SX -> SX -> Bool -> IO SX -jacobianTimesVector__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_jacobianTimesVector__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__0" c_linsolIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -linsolIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -linsolIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__1" c_linsolIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -linsolIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -linsolIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__2" c_linsolIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -linsolIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -linsolIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__3" c_linsolIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -linsolIn__3 - :: Vector DMatrix -> IO (Vector DMatrix) -linsolIn__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__4" c_linsolIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -linsolIn__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -linsolIn__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__5" c_linsolIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -linsolIn__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -linsolIn__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__6" c_linsolIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -linsolIn__6 - :: Vector MX -> IO (Vector MX) -linsolIn__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__7" c_linsolIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -linsolIn__7 - :: Vector MX -> String -> IO (Vector MX) -linsolIn__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__8" c_linsolIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -linsolIn__8 - :: Vector MX -> String -> String -> IO (Vector MX) -linsolIn__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__9" c_linsolIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -linsolIn__9 - :: Vector SX -> IO (Vector SX) -linsolIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__10" c_linsolIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -linsolIn__10 - :: Vector SX -> String -> IO (Vector SX) -linsolIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolIn__11" c_linsolIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -linsolIn__11 - :: Vector SX -> String -> String -> IO (Vector SX) -linsolIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__0" c_linsolOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -linsolOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -linsolOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__1" c_linsolOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -linsolOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -linsolOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__2" c_linsolOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -linsolOut__2 - :: Vector DMatrix -> IO (Vector DMatrix) -linsolOut__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__3" c_linsolOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -linsolOut__3 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -linsolOut__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__4" c_linsolOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -linsolOut__4 - :: Vector MX -> IO (Vector MX) -linsolOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__5" c_linsolOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -linsolOut__5 - :: Vector MX -> String -> IO (Vector MX) -linsolOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__6" c_linsolOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -linsolOut__6 - :: Vector SX -> IO (Vector SX) -linsolOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "linsolOut__7" c_linsolOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -linsolOut__7 - :: Vector SX -> String -> IO (Vector SX) -linsolOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_linsolOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_and__0" c_logic_and__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -logic_and__0 - :: MX -> MX -> IO MX -logic_and__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_and__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_and__1" c_logic_and__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -logic_and__1 - :: SX -> SX -> IO SX -logic_and__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_and__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_and__2" c_logic_and__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -logic_and__2 - :: DMatrix -> DMatrix -> IO DMatrix -logic_and__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_and__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_and__3" c_logic_and__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -logic_and__3 - :: IMatrix -> IMatrix -> IO IMatrix -logic_and__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_and__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_and__4" c_logic_and__4 - :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble -logic_and__4 - :: Double -> Double -> IO Double -logic_and__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_and__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_and__5" c_logic_and__5 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt -logic_and__5 - :: Int -> Int -> IO Int -logic_and__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_and__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_not__0" c_logic_not__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -logic_not__0 - :: MX -> IO MX -logic_not__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_not__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_not__1" c_logic_not__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -logic_not__1 - :: SX -> IO SX -logic_not__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_not__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_not__2" c_logic_not__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -logic_not__2 - :: DMatrix -> IO DMatrix -logic_not__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_not__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_not__3" c_logic_not__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -logic_not__3 - :: IMatrix -> IO IMatrix -logic_not__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_not__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_not__4" c_logic_not__4 - :: Ptr (Ptr StdString) -> CDouble -> IO CDouble -logic_not__4 - :: Double -> IO Double -logic_not__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_not__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_not__5" c_logic_not__5 - :: Ptr (Ptr StdString) -> CInt -> IO CInt -logic_not__5 - :: Int -> IO Int -logic_not__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_not__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_or__0" c_logic_or__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -logic_or__0 - :: MX -> MX -> IO MX -logic_or__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_or__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_or__1" c_logic_or__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -logic_or__1 - :: SX -> SX -> IO SX -logic_or__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_or__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_or__2" c_logic_or__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -logic_or__2 - :: DMatrix -> DMatrix -> IO DMatrix -logic_or__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_or__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_or__3" c_logic_or__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -logic_or__3 - :: IMatrix -> IMatrix -> IO IMatrix -logic_or__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_or__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_or__4" c_logic_or__4 - :: Ptr (Ptr StdString) -> CDouble -> CDouble -> IO CDouble -logic_or__4 - :: Double -> Double -> IO Double -logic_or__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_or__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "logic_or__5" c_logic_or__5 - :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt -logic_or__5 - :: Int -> Int -> IO Int -logic_or__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_logic_or__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lookupvector" c_lookupvector - :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) -lookupvector - :: Vector Int -> Int -> IO (Vector Int) -lookupvector x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lookupvector errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__0" c_lpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__1" c_lpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__2" c_lpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -lpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__3" c_lpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -lpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__4" c_lpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -lpIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__5" c_lpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -lpIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__6" c_lpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -lpIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__7" c_lpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpIn__7 - :: Vector DMatrix -> IO (Vector DMatrix) -lpIn__7 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__7 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__8" c_lpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpIn__8 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -lpIn__8 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__8 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__9" c_lpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpIn__9 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -lpIn__9 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__9 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__10" c_lpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpIn__10 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -lpIn__10 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__10 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__11" c_lpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpIn__11 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -lpIn__11 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__11 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__12" c_lpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpIn__12 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -lpIn__12 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__13" c_lpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpIn__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -lpIn__13 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__14" c_lpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -lpIn__14 - :: Vector MX -> IO (Vector MX) -lpIn__14 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__14 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__15" c_lpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpIn__15 - :: Vector MX -> String -> IO (Vector MX) -lpIn__15 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__15 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__16" c_lpIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpIn__16 - :: Vector MX -> String -> String -> IO (Vector MX) -lpIn__16 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__16 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__17" c_lpIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpIn__17 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -lpIn__17 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__17 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__18" c_lpIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpIn__18 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -lpIn__18 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__18 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__19" c_lpIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpIn__19 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -lpIn__19 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__20" c_lpIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpIn__20 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -lpIn__20 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__21" c_lpIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -lpIn__21 - :: Vector SX -> IO (Vector SX) -lpIn__21 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__21 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__22" c_lpIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpIn__22 - :: Vector SX -> String -> IO (Vector SX) -lpIn__22 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__22 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__23" c_lpIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpIn__23 - :: Vector SX -> String -> String -> IO (Vector SX) -lpIn__23 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__23 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__24" c_lpIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpIn__24 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -lpIn__24 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__24 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__25" c_lpIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpIn__25 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -lpIn__25 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__25 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__26" c_lpIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpIn__26 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -lpIn__26 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpIn__27" c_lpIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpIn__27 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -lpIn__27 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__0" c_lpOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lpOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__1" c_lpOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lpOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__2" c_lpOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -lpOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__3" c_lpOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -lpOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__4" c_lpOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -lpOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__5" c_lpOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpOut__5 - :: Vector DMatrix -> IO (Vector DMatrix) -lpOut__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__6" c_lpOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpOut__6 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -lpOut__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__7" c_lpOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpOut__7 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -lpOut__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__8" c_lpOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpOut__8 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -lpOut__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__9" c_lpOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lpOut__9 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -lpOut__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__10" c_lpOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -lpOut__10 - :: Vector MX -> IO (Vector MX) -lpOut__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__11" c_lpOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpOut__11 - :: Vector MX -> String -> IO (Vector MX) -lpOut__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__12" c_lpOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpOut__12 - :: Vector MX -> String -> String -> IO (Vector MX) -lpOut__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__13" c_lpOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpOut__13 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -lpOut__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__14" c_lpOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lpOut__14 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -lpOut__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__15" c_lpOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -lpOut__15 - :: Vector SX -> IO (Vector SX) -lpOut__15 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__15 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__16" c_lpOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpOut__16 - :: Vector SX -> String -> IO (Vector SX) -lpOut__16 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__16 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__17" c_lpOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpOut__17 - :: Vector SX -> String -> String -> IO (Vector SX) -lpOut__17 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__17 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__18" c_lpOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpOut__18 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -lpOut__18 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__18 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpOut__19" c_lpOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lpOut__19 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -lpOut__19 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpOut__19 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpStruct__0" c_lpStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lpStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lpStruct__1" c_lpStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lpStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lpStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lpStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__0" c_lrdleIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lrdleIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__1" c_lrdleIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lrdleIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__2" c_lrdleIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -lrdleIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__3" c_lrdleIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -lrdleIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__4" c_lrdleIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -lrdleIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__5" c_lrdleIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdleIn__5 - :: Vector DMatrix -> IO (Vector DMatrix) -lrdleIn__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__6" c_lrdleIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdleIn__6 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -lrdleIn__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__7" c_lrdleIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdleIn__7 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -lrdleIn__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__8" c_lrdleIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdleIn__8 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -lrdleIn__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__9" c_lrdleIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdleIn__9 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -lrdleIn__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__10" c_lrdleIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -lrdleIn__10 - :: Vector MX -> IO (Vector MX) -lrdleIn__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__11" c_lrdleIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdleIn__11 - :: Vector MX -> String -> IO (Vector MX) -lrdleIn__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__12" c_lrdleIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdleIn__12 - :: Vector MX -> String -> String -> IO (Vector MX) -lrdleIn__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__13" c_lrdleIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdleIn__13 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -lrdleIn__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__14" c_lrdleIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdleIn__14 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -lrdleIn__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__15" c_lrdleIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -lrdleIn__15 - :: Vector SX -> IO (Vector SX) -lrdleIn__15 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__15 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__16" c_lrdleIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdleIn__16 - :: Vector SX -> String -> IO (Vector SX) -lrdleIn__16 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__16 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__17" c_lrdleIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdleIn__17 - :: Vector SX -> String -> String -> IO (Vector SX) -lrdleIn__17 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__17 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__18" c_lrdleIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdleIn__18 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -lrdleIn__18 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__18 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleIn__19" c_lrdleIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdleIn__19 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -lrdleIn__19 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleIn__19 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__0" c_lrdleOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lrdleOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__1" c_lrdleOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lrdleOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__2" c_lrdleOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdleOut__2 - :: Vector DMatrix -> IO (Vector DMatrix) -lrdleOut__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__3" c_lrdleOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdleOut__3 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -lrdleOut__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__4" c_lrdleOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -lrdleOut__4 - :: Vector MX -> IO (Vector MX) -lrdleOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__5" c_lrdleOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdleOut__5 - :: Vector MX -> String -> IO (Vector MX) -lrdleOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__6" c_lrdleOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -lrdleOut__6 - :: Vector SX -> IO (Vector SX) -lrdleOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleOut__7" c_lrdleOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdleOut__7 - :: Vector SX -> String -> IO (Vector SX) -lrdleOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleStruct__0" c_lrdleStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lrdleStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleStruct__1" c_lrdleStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lrdleStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleStruct__2" c_lrdleStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -lrdleStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleStruct__3" c_lrdleStruct__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleStruct__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -lrdleStruct__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleStruct__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdleStruct__4" c_lrdleStruct__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdleStruct__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -lrdleStruct__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdleStruct__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__0" c_lrdpleIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdpleIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lrdpleIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__1" c_lrdpleIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdpleIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lrdpleIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__2" c_lrdpleIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdpleIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -lrdpleIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__3" c_lrdpleIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdpleIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -lrdpleIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__4" c_lrdpleIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdpleIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -lrdpleIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__5" c_lrdpleIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdpleIn__5 - :: Vector DMatrix -> IO (Vector DMatrix) -lrdpleIn__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__6" c_lrdpleIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdpleIn__6 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -lrdpleIn__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__7" c_lrdpleIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdpleIn__7 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -lrdpleIn__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__8" c_lrdpleIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdpleIn__8 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -lrdpleIn__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__9" c_lrdpleIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdpleIn__9 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -lrdpleIn__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__10" c_lrdpleIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -lrdpleIn__10 - :: Vector MX -> IO (Vector MX) -lrdpleIn__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__11" c_lrdpleIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdpleIn__11 - :: Vector MX -> String -> IO (Vector MX) -lrdpleIn__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__12" c_lrdpleIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdpleIn__12 - :: Vector MX -> String -> String -> IO (Vector MX) -lrdpleIn__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__13" c_lrdpleIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdpleIn__13 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -lrdpleIn__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__14" c_lrdpleIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdpleIn__14 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -lrdpleIn__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__15" c_lrdpleIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -lrdpleIn__15 - :: Vector SX -> IO (Vector SX) -lrdpleIn__15 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__15 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__16" c_lrdpleIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdpleIn__16 - :: Vector SX -> String -> IO (Vector SX) -lrdpleIn__16 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__16 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__17" c_lrdpleIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdpleIn__17 - :: Vector SX -> String -> String -> IO (Vector SX) -lrdpleIn__17 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__17 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__18" c_lrdpleIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdpleIn__18 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -lrdpleIn__18 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__18 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleIn__19" c_lrdpleIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdpleIn__19 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -lrdpleIn__19 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleIn__19 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__0" c_lrdpleOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdpleOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -lrdpleOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__1" c_lrdpleOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -lrdpleOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -lrdpleOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__2" c_lrdpleOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdpleOut__2 - :: Vector DMatrix -> IO (Vector DMatrix) -lrdpleOut__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__3" c_lrdpleOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -lrdpleOut__3 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -lrdpleOut__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__4" c_lrdpleOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -lrdpleOut__4 - :: Vector MX -> IO (Vector MX) -lrdpleOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__5" c_lrdpleOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -lrdpleOut__5 - :: Vector MX -> String -> IO (Vector MX) -lrdpleOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__6" c_lrdpleOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -lrdpleOut__6 - :: Vector SX -> IO (Vector SX) -lrdpleOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleOut__7" c_lrdpleOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -lrdpleOut__7 - :: Vector SX -> String -> IO (Vector SX) -lrdpleOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleStruct__0" c_lrdpleStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -lrdpleStruct__0 - :: Vector (Vector Sparsity) -> IO (Vector (Vector Sparsity)) -lrdpleStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleStruct__1" c_lrdpleStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -lrdpleStruct__1 - :: Vector (Vector Sparsity) -> String -> IO (Vector (Vector Sparsity)) -lrdpleStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleStruct__2" c_lrdpleStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -lrdpleStruct__2 - :: Vector (Vector Sparsity) -> String -> String -> IO (Vector (Vector Sparsity)) -lrdpleStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleStruct__3" c_lrdpleStruct__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -lrdpleStruct__3 - :: Vector (Vector Sparsity) -> String -> String -> String -> IO (Vector (Vector Sparsity)) -lrdpleStruct__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleStruct__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "lrdpleStruct__4" c_lrdpleStruct__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) -lrdpleStruct__4 - :: Vector (Vector Sparsity) -> String -> String -> String -> String -> IO (Vector (Vector Sparsity)) -lrdpleStruct__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_lrdpleStruct__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "matrix_expand__0" c_matrix_expand__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -matrix_expand__0 - :: Vector MX -> IO (Vector MX) -matrix_expand__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_matrix_expand__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "matrix_expand__1" c_matrix_expand__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -matrix_expand__1 - :: Vector MX -> Vector MX -> IO (Vector MX) -matrix_expand__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_matrix_expand__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "matrix_expand__2" c_matrix_expand__2 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') -matrix_expand__2 - :: MX -> IO MX -matrix_expand__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_matrix_expand__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "matrix_expand__3" c_matrix_expand__3 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') -matrix_expand__3 - :: MX -> Vector MX -> IO MX -matrix_expand__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_matrix_expand__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "mtaylor__0" c_mtaylor__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr SX') -mtaylor__0 - :: SX -> SX -> SX -> Int -> Vector Int -> IO SX -mtaylor__0 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "mtaylor__1" c_mtaylor__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -mtaylor__1 - :: SX -> SX -> SX -> IO SX -mtaylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_mtaylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "mtaylor__2" c_mtaylor__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -mtaylor__2 - :: SX -> SX -> SX -> Int -> IO SX -mtaylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_mtaylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__0" c_nlpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -nlpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__1" c_nlpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -nlpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__2" c_nlpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -nlpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__3" c_nlpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpIn__3 - :: Vector DMatrix -> IO (Vector DMatrix) -nlpIn__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__4" c_nlpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpIn__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -nlpIn__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__5" c_nlpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpIn__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -nlpIn__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__6" c_nlpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -nlpIn__6 - :: Vector MX -> IO (Vector MX) -nlpIn__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__7" c_nlpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpIn__7 - :: Vector MX -> String -> IO (Vector MX) -nlpIn__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__8" c_nlpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpIn__8 - :: Vector MX -> String -> String -> IO (Vector MX) -nlpIn__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__9" c_nlpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -nlpIn__9 - :: Vector SX -> IO (Vector SX) -nlpIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__10" c_nlpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpIn__10 - :: Vector SX -> String -> IO (Vector SX) -nlpIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpIn__11" c_nlpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpIn__11 - :: Vector SX -> String -> String -> IO (Vector SX) -nlpIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__0" c_nlpOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -nlpOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__1" c_nlpOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -nlpOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__2" c_nlpOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -nlpOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__3" c_nlpOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpOut__3 - :: Vector DMatrix -> IO (Vector DMatrix) -nlpOut__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__4" c_nlpOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpOut__4 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -nlpOut__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__5" c_nlpOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpOut__5 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -nlpOut__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__6" c_nlpOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -nlpOut__6 - :: Vector MX -> IO (Vector MX) -nlpOut__6 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__6 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__7" c_nlpOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpOut__7 - :: Vector MX -> String -> IO (Vector MX) -nlpOut__7 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__7 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__8" c_nlpOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpOut__8 - :: Vector MX -> String -> String -> IO (Vector MX) -nlpOut__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__9" c_nlpOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -nlpOut__9 - :: Vector SX -> IO (Vector SX) -nlpOut__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__10" c_nlpOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpOut__10 - :: Vector SX -> String -> IO (Vector SX) -nlpOut__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpOut__11" c_nlpOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpOut__11 - :: Vector SX -> String -> String -> IO (Vector SX) -nlpOut__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpOut__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__0" c_nlpSolverIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -nlpSolverIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__1" c_nlpSolverIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -nlpSolverIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__2" c_nlpSolverIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -nlpSolverIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__3" c_nlpSolverIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__4" c_nlpSolverIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__5" c_nlpSolverIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__6" c_nlpSolverIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__7" c_nlpSolverIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__8" c_nlpSolverIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__9" c_nlpSolverIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__9 - :: Vector DMatrix -> IO (Vector DMatrix) -nlpSolverIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__10" c_nlpSolverIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__10 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -nlpSolverIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__11" c_nlpSolverIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__11 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -nlpSolverIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__12" c_nlpSolverIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__12 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverIn__12 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__12 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__13" c_nlpSolverIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__13 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverIn__13 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__13 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__14" c_nlpSolverIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__14 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverIn__14 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__15" c_nlpSolverIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverIn__15 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__16" c_nlpSolverIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__16 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverIn__16 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__17" c_nlpSolverIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__18" c_nlpSolverIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__18 - :: Vector MX -> IO (Vector MX) -nlpSolverIn__18 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__18 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__19" c_nlpSolverIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__19 - :: Vector MX -> String -> IO (Vector MX) -nlpSolverIn__19 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__19 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__20" c_nlpSolverIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__20 - :: Vector MX -> String -> String -> IO (Vector MX) -nlpSolverIn__20 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__20 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__21" c_nlpSolverIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__21 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -nlpSolverIn__21 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__21 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__22" c_nlpSolverIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__22 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverIn__22 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__22 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__23" c_nlpSolverIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__23 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverIn__23 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__24" c_nlpSolverIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__24 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverIn__24 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__25" c_nlpSolverIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__25 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverIn__25 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__26" c_nlpSolverIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverIn__26 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__27" c_nlpSolverIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__27 - :: Vector SX -> IO (Vector SX) -nlpSolverIn__27 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__27 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__28" c_nlpSolverIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__28 - :: Vector SX -> String -> IO (Vector SX) -nlpSolverIn__28 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__28 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__29" c_nlpSolverIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__29 - :: Vector SX -> String -> String -> IO (Vector SX) -nlpSolverIn__29 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__29 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__30" c_nlpSolverIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__30 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -nlpSolverIn__30 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__30 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__31" c_nlpSolverIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__31 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverIn__31 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__31 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__32" c_nlpSolverIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__32 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverIn__32 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__33" c_nlpSolverIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__33 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverIn__33 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__34" c_nlpSolverIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__34 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverIn__34 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverIn__35" c_nlpSolverIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverIn__35 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__0" c_nlpSolverOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -nlpSolverOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__1" c_nlpSolverOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -nlpSolverOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__2" c_nlpSolverOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -nlpSolverOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__3" c_nlpSolverOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__4" c_nlpSolverOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__5" c_nlpSolverOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverOut__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverOut__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__6" c_nlpSolverOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -nlpSolverOut__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -nlpSolverOut__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__7" c_nlpSolverOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverOut__7 - :: Vector DMatrix -> IO (Vector DMatrix) -nlpSolverOut__7 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__7 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__8" c_nlpSolverOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverOut__8 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -nlpSolverOut__8 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__8 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__9" c_nlpSolverOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverOut__9 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -nlpSolverOut__9 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__9 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__10" c_nlpSolverOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverOut__10 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverOut__10 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__10 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__11" c_nlpSolverOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverOut__11 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverOut__11 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__11 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__12" c_nlpSolverOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverOut__12 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverOut__12 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__13" c_nlpSolverOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -nlpSolverOut__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -nlpSolverOut__13 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__14" c_nlpSolverOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverOut__14 - :: Vector MX -> IO (Vector MX) -nlpSolverOut__14 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__14 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__15" c_nlpSolverOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverOut__15 - :: Vector MX -> String -> IO (Vector MX) -nlpSolverOut__15 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__15 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__16" c_nlpSolverOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverOut__16 - :: Vector MX -> String -> String -> IO (Vector MX) -nlpSolverOut__16 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__16 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__17" c_nlpSolverOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverOut__17 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -nlpSolverOut__17 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__17 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__18" c_nlpSolverOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverOut__18 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverOut__18 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__18 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__19" c_nlpSolverOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverOut__19 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverOut__19 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__20" c_nlpSolverOut__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -nlpSolverOut__20 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -nlpSolverOut__20 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__21" c_nlpSolverOut__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverOut__21 - :: Vector SX -> IO (Vector SX) -nlpSolverOut__21 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__21 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__22" c_nlpSolverOut__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverOut__22 - :: Vector SX -> String -> IO (Vector SX) -nlpSolverOut__22 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__22 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__23" c_nlpSolverOut__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverOut__23 - :: Vector SX -> String -> String -> IO (Vector SX) -nlpSolverOut__23 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__23 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__24" c_nlpSolverOut__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverOut__24 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -nlpSolverOut__24 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__24 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__25" c_nlpSolverOut__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverOut__25 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverOut__25 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__25 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__26" c_nlpSolverOut__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverOut__26 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverOut__26 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "nlpSolverOut__27" c_nlpSolverOut__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -nlpSolverOut__27 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -nlpSolverOut__27 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_nlpSolverOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "pinv__0" c_pinv__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') -pinv__0 - :: MX -> String -> IO MX -pinv__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_pinv__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "pinv__1" c_pinv__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -pinv__1 - :: SX -> IO SX -pinv__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_pinv__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "pinv__2" c_pinv__2 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') -pinv__2 - :: DMatrix -> IO DMatrix -pinv__2 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_pinv__2 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "pinv__3" c_pinv__3 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') -pinv__3 - :: IMatrix -> IO IMatrix -pinv__3 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_pinv__3 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "pinv__4" c_pinv__4 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix') -pinv__4 - :: DMatrix -> String -> IO DMatrix -pinv__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_pinv__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "poly_coeff" c_poly_coeff - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -poly_coeff - :: SX -> SX -> IO SX -poly_coeff x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_poly_coeff errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "poly_roots" c_poly_roots - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -poly_roots - :: SX -> IO SX -poly_roots x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_poly_roots errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "printCompact__0" c_printCompact__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> IO () -printCompact__0 - :: MX -> IO () -printCompact__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_printCompact__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "printCompact__1" c_printCompact__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> IO () -printCompact__1 - :: SX -> IO () -printCompact__1 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_printCompact__1 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "pw_const" c_pw_const - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -pw_const - :: SX -> SX -> SX -> IO SX -pw_const x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_pw_const errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "pw_lin" c_pw_lin - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -pw_lin - :: SX -> SX -> SX -> IO SX -pw_lin x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_pw_lin errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__0" c_qcqpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -qcqpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__1" c_qcqpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -qcqpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__2" c_qcqpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -qcqpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__3" c_qcqpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__4" c_qcqpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__5" c_qcqpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__6" c_qcqpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__7" c_qcqpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__8" c_qcqpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__9" c_qcqpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__9 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__10" c_qcqpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__10 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__11" c_qcqpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__11 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__12" c_qcqpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpIn__12 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__13" c_qcqpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__13 - :: Vector DMatrix -> IO (Vector DMatrix) -qcqpIn__13 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__13 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__14" c_qcqpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__14 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -qcqpIn__14 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__14 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__15" c_qcqpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__15 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -qcqpIn__15 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__15 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__16" c_qcqpIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__16 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__16 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__16 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__17" c_qcqpIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__17 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__17 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__18" c_qcqpIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__18 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__18 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__19" c_qcqpIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__19 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__19 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__20" c_qcqpIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__20 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__21" c_qcqpIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__21 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__22" c_qcqpIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__22 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__23" c_qcqpIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__23 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__24" c_qcqpIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__24 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__25" c_qcqpIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpIn__25 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__26" c_qcqpIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__26 - :: Vector MX -> IO (Vector MX) -qcqpIn__26 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__26 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__27" c_qcqpIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__27 - :: Vector MX -> String -> IO (Vector MX) -qcqpIn__27 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__27 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__28" c_qcqpIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__28 - :: Vector MX -> String -> String -> IO (Vector MX) -qcqpIn__28 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__28 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__29" c_qcqpIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__29 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -qcqpIn__29 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__29 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__30" c_qcqpIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__30 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__30 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__30 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__31" c_qcqpIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__31 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__31 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__32" c_qcqpIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__32 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__32 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__33" c_qcqpIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__33 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__34" c_qcqpIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__34 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__35" c_qcqpIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__35 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__36" c_qcqpIn__36 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__36 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__37" c_qcqpIn__37 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__37 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__38" c_qcqpIn__38 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpIn__38 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qcqpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__39" c_qcqpIn__39 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__39 - :: Vector SX -> IO (Vector SX) -qcqpIn__39 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__39 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__40" c_qcqpIn__40 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__40 - :: Vector SX -> String -> IO (Vector SX) -qcqpIn__40 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__40 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__41" c_qcqpIn__41 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__41 - :: Vector SX -> String -> String -> IO (Vector SX) -qcqpIn__41 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__41 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__42" c_qcqpIn__42 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__42 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -qcqpIn__42 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__42 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__43" c_qcqpIn__43 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__43 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__43 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__43 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__44" c_qcqpIn__44 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__44 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__44 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__45" c_qcqpIn__45 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__45 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__45 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__46" c_qcqpIn__46 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__46 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__47" c_qcqpIn__47 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__47 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__48" c_qcqpIn__48 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__48 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__49" c_qcqpIn__49 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__49 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__50" c_qcqpIn__50 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__50 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpIn__51" c_qcqpIn__51 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpIn__51 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qcqpIn__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__0" c_qcqpOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -qcqpOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__1" c_qcqpOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -qcqpOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__2" c_qcqpOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -qcqpOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__3" c_qcqpOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -qcqpOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__4" c_qcqpOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -qcqpOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__5" c_qcqpOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpOut__5 - :: Vector DMatrix -> IO (Vector DMatrix) -qcqpOut__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__6" c_qcqpOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpOut__6 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -qcqpOut__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__7" c_qcqpOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpOut__7 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -qcqpOut__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__8" c_qcqpOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpOut__8 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -qcqpOut__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__9" c_qcqpOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qcqpOut__9 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -qcqpOut__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__10" c_qcqpOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -qcqpOut__10 - :: Vector MX -> IO (Vector MX) -qcqpOut__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__11" c_qcqpOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpOut__11 - :: Vector MX -> String -> IO (Vector MX) -qcqpOut__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__12" c_qcqpOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpOut__12 - :: Vector MX -> String -> String -> IO (Vector MX) -qcqpOut__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__13" c_qcqpOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpOut__13 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -qcqpOut__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__14" c_qcqpOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qcqpOut__14 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -qcqpOut__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__15" c_qcqpOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -qcqpOut__15 - :: Vector SX -> IO (Vector SX) -qcqpOut__15 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__15 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__16" c_qcqpOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpOut__16 - :: Vector SX -> String -> IO (Vector SX) -qcqpOut__16 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__16 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__17" c_qcqpOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpOut__17 - :: Vector SX -> String -> String -> IO (Vector SX) -qcqpOut__17 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__17 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__18" c_qcqpOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpOut__18 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -qcqpOut__18 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__18 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpOut__19" c_qcqpOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qcqpOut__19 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -qcqpOut__19 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpOut__19 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpStruct__0" c_qcqpStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -qcqpStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpStruct__1" c_qcqpStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -qcqpStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpStruct__2" c_qcqpStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -qcqpStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qcqpStruct__3" c_qcqpStruct__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qcqpStruct__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -qcqpStruct__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qcqpStruct__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__0" c_qpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -qpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__1" c_qpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -qpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__2" c_qpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -qpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__3" c_qpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -qpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__4" c_qpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -qpIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__5" c_qpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qpIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__6" c_qpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qpIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__7" c_qpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__8" c_qpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__9" c_qpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpIn__9 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -qpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__10" c_qpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__10 - :: Vector DMatrix -> IO (Vector DMatrix) -qpIn__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__11" c_qpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__11 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -qpIn__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__12" c_qpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__12 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -qpIn__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__13" c_qpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__13 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -qpIn__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__14" c_qpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__14 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -qpIn__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__15" c_qpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qpIn__15 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__16" c_qpIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__16 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qpIn__16 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__17" c_qpIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__18" c_qpIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__18 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__19" c_qpIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpIn__19 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -qpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__20" c_qpIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__20 - :: Vector MX -> IO (Vector MX) -qpIn__20 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__20 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__21" c_qpIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__21 - :: Vector MX -> String -> IO (Vector MX) -qpIn__21 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__21 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__22" c_qpIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__22 - :: Vector MX -> String -> String -> IO (Vector MX) -qpIn__22 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__22 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__23" c_qpIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__23 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -qpIn__23 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__23 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__24" c_qpIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__24 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -qpIn__24 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__24 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__25" c_qpIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__25 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -qpIn__25 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__26" c_qpIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__26 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qpIn__26 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__27" c_qpIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__27 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__28" c_qpIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__28 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__29" c_qpIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpIn__29 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -qpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__30" c_qpIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__30 - :: Vector SX -> IO (Vector SX) -qpIn__30 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__30 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__31" c_qpIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__31 - :: Vector SX -> String -> IO (Vector SX) -qpIn__31 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__31 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__32" c_qpIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__32 - :: Vector SX -> String -> String -> IO (Vector SX) -qpIn__32 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__32 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__33" c_qpIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__33 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -qpIn__33 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__33 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__34" c_qpIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__34 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -qpIn__34 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__34 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__35" c_qpIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__35 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -qpIn__35 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__36" c_qpIn__36 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__36 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qpIn__36 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__37" c_qpIn__37 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__37 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__38" c_qpIn__38 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__38 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpIn__39" c_qpIn__39 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpIn__39 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -qpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__0" c_qpOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -qpOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__1" c_qpOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -qpOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__2" c_qpOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -qpOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__3" c_qpOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -qpOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__4" c_qpOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -qpOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__5" c_qpOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpOut__5 - :: Vector DMatrix -> IO (Vector DMatrix) -qpOut__5 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__5 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__6" c_qpOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpOut__6 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -qpOut__6 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__6 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__7" c_qpOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpOut__7 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -qpOut__7 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__7 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__8" c_qpOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpOut__8 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -qpOut__8 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__8 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__9" c_qpOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -qpOut__9 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -qpOut__9 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__9 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__10" c_qpOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -qpOut__10 - :: Vector MX -> IO (Vector MX) -qpOut__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__11" c_qpOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpOut__11 - :: Vector MX -> String -> IO (Vector MX) -qpOut__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__12" c_qpOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpOut__12 - :: Vector MX -> String -> String -> IO (Vector MX) -qpOut__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__13" c_qpOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpOut__13 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -qpOut__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__14" c_qpOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -qpOut__14 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -qpOut__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__15" c_qpOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -qpOut__15 - :: Vector SX -> IO (Vector SX) -qpOut__15 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__15 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__16" c_qpOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpOut__16 - :: Vector SX -> String -> IO (Vector SX) -qpOut__16 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__16 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__17" c_qpOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpOut__17 - :: Vector SX -> String -> String -> IO (Vector SX) -qpOut__17 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__17 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__18" c_qpOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpOut__18 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -qpOut__18 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__18 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpOut__19" c_qpOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -qpOut__19 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -qpOut__19 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpOut__19 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpStruct__0" c_qpStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -qpStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpStruct__1" c_qpStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -qpStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "qpStruct__2" c_qpStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -qpStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -qpStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_qpStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "ramp" c_ramp - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -ramp - :: SX -> IO SX -ramp x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_ramp errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__0" c_rdaeIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -rdaeIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__1" c_rdaeIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -rdaeIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__2" c_rdaeIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -rdaeIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__3" c_rdaeIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -rdaeIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__4" c_rdaeIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -rdaeIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__5" c_rdaeIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -rdaeIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__6" c_rdaeIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -rdaeIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__7" c_rdaeIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -rdaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__8" c_rdaeIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__8 - :: Vector DMatrix -> IO (Vector DMatrix) -rdaeIn__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__9" c_rdaeIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__9 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -rdaeIn__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__10" c_rdaeIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__10 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -rdaeIn__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__11" c_rdaeIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__11 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -rdaeIn__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__12" c_rdaeIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__12 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -rdaeIn__12 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__12 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__13" c_rdaeIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -rdaeIn__13 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__14" c_rdaeIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__14 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -rdaeIn__14 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__15" c_rdaeIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeIn__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -rdaeIn__15 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__16" c_rdaeIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__16 - :: Vector MX -> IO (Vector MX) -rdaeIn__16 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__16 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__17" c_rdaeIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__17 - :: Vector MX -> String -> IO (Vector MX) -rdaeIn__17 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__17 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__18" c_rdaeIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__18 - :: Vector MX -> String -> String -> IO (Vector MX) -rdaeIn__18 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__18 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__19" c_rdaeIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__19 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -rdaeIn__19 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__19 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__20" c_rdaeIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__20 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -rdaeIn__20 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__20 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__21" c_rdaeIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__21 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -rdaeIn__21 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__22" c_rdaeIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__22 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -rdaeIn__22 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__23" c_rdaeIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeIn__23 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -rdaeIn__23 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__24" c_rdaeIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__24 - :: Vector SX -> IO (Vector SX) -rdaeIn__24 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__24 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__25" c_rdaeIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__25 - :: Vector SX -> String -> IO (Vector SX) -rdaeIn__25 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__25 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__26" c_rdaeIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__26 - :: Vector SX -> String -> String -> IO (Vector SX) -rdaeIn__26 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__26 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__27" c_rdaeIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__27 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -rdaeIn__27 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__27 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__28" c_rdaeIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__28 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -rdaeIn__28 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__28 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__29" c_rdaeIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__29 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -rdaeIn__29 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__30" c_rdaeIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__30 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -rdaeIn__30 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeIn__31" c_rdaeIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeIn__31 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -rdaeIn__31 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__0" c_rdaeOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -rdaeOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__1" c_rdaeOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -rdaeOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__2" c_rdaeOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -rdaeOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__3" c_rdaeOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -rdaeOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -rdaeOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__4" c_rdaeOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeOut__4 - :: Vector DMatrix -> IO (Vector DMatrix) -rdaeOut__4 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__4 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__5" c_rdaeOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeOut__5 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -rdaeOut__5 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__5 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__6" c_rdaeOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeOut__6 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -rdaeOut__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__7" c_rdaeOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -rdaeOut__7 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -rdaeOut__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__8" c_rdaeOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -rdaeOut__8 - :: Vector MX -> IO (Vector MX) -rdaeOut__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__9" c_rdaeOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeOut__9 - :: Vector MX -> String -> IO (Vector MX) -rdaeOut__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__10" c_rdaeOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeOut__10 - :: Vector MX -> String -> String -> IO (Vector MX) -rdaeOut__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__11" c_rdaeOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -rdaeOut__11 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -rdaeOut__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__12" c_rdaeOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -rdaeOut__12 - :: Vector SX -> IO (Vector SX) -rdaeOut__12 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__12 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__13" c_rdaeOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeOut__13 - :: Vector SX -> String -> IO (Vector SX) -rdaeOut__13 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__13 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__14" c_rdaeOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeOut__14 - :: Vector SX -> String -> String -> IO (Vector SX) -rdaeOut__14 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__14 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rdaeOut__15" c_rdaeOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -rdaeOut__15 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -rdaeOut__15 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_rdaeOut__15 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "rectangle" c_rectangle - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -rectangle - :: SX -> IO SX -rectangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_rectangle errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__0" c_sdpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -sdpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__1" c_sdpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -sdpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__2" c_sdpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -sdpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__3" c_sdpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -sdpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__4" c_sdpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__5" c_sdpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__6" c_sdpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__7" c_sdpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__8" c_sdpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__9" c_sdpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__9 - :: Vector DMatrix -> IO (Vector DMatrix) -sdpIn__9 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__9 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__10" c_sdpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__10 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -sdpIn__10 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__10 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__11" c_sdpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__11 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -sdpIn__11 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__11 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__12" c_sdpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__12 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -sdpIn__12 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__12 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__13" c_sdpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__13 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpIn__13 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__13 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__14" c_sdpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__14 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpIn__14 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__15" c_sdpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpIn__15 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__16" c_sdpIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__16 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__17" c_sdpIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__18" c_sdpIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__18 - :: Vector MX -> IO (Vector MX) -sdpIn__18 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__18 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__19" c_sdpIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__19 - :: Vector MX -> String -> IO (Vector MX) -sdpIn__19 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__19 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__20" c_sdpIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__20 - :: Vector MX -> String -> String -> IO (Vector MX) -sdpIn__20 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__20 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__21" c_sdpIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__21 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -sdpIn__21 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__21 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__22" c_sdpIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__22 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -sdpIn__22 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__22 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__23" c_sdpIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__23 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -sdpIn__23 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__24" c_sdpIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__24 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdpIn__24 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__25" c_sdpIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__25 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__26" c_sdpIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpIn__26 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__27" c_sdpIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__27 - :: Vector SX -> IO (Vector SX) -sdpIn__27 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__27 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__28" c_sdpIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__28 - :: Vector SX -> String -> IO (Vector SX) -sdpIn__28 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__28 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__29" c_sdpIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__29 - :: Vector SX -> String -> String -> IO (Vector SX) -sdpIn__29 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__29 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__30" c_sdpIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__30 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -sdpIn__30 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__30 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__31" c_sdpIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__31 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -sdpIn__31 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__31 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__32" c_sdpIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__32 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -sdpIn__32 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__33" c_sdpIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__33 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdpIn__33 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__34" c_sdpIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__34 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpIn__35" c_sdpIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpIn__35 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__0" c_sdpOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -sdpOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__1" c_sdpOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -sdpOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__2" c_sdpOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -sdpOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__3" c_sdpOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -sdpOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__4" c_sdpOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__5" c_sdpOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpOut__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__6" c_sdpOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpOut__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__7" c_sdpOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpOut__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__8" c_sdpOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__8 - :: Vector DMatrix -> IO (Vector DMatrix) -sdpOut__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__9" c_sdpOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__9 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -sdpOut__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__10" c_sdpOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__10 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -sdpOut__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__11" c_sdpOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__11 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -sdpOut__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__12" c_sdpOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__12 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpOut__12 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__12 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__13" c_sdpOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpOut__13 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__14" c_sdpOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__14 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpOut__14 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__15" c_sdpOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdpOut__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdpOut__15 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__16" c_sdpOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__16 - :: Vector MX -> IO (Vector MX) -sdpOut__16 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__16 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__17" c_sdpOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__17 - :: Vector MX -> String -> IO (Vector MX) -sdpOut__17 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__17 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__18" c_sdpOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__18 - :: Vector MX -> String -> String -> IO (Vector MX) -sdpOut__18 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__18 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__19" c_sdpOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__19 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -sdpOut__19 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__19 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__20" c_sdpOut__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__20 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -sdpOut__20 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__20 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__21" c_sdpOut__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__21 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -sdpOut__21 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__22" c_sdpOut__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__22 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdpOut__22 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__23" c_sdpOut__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdpOut__23 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__24" c_sdpOut__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__24 - :: Vector SX -> IO (Vector SX) -sdpOut__24 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__24 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__25" c_sdpOut__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__25 - :: Vector SX -> String -> IO (Vector SX) -sdpOut__25 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__25 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__26" c_sdpOut__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__26 - :: Vector SX -> String -> String -> IO (Vector SX) -sdpOut__26 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__26 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__27" c_sdpOut__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__27 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -sdpOut__27 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__27 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__28" c_sdpOut__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__28 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -sdpOut__28 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__28 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__29" c_sdpOut__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__29 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -sdpOut__29 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__30" c_sdpOut__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__30 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdpOut__30 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpOut__31" c_sdpOut__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdpOut__31 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdpOut__31 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpStruct__0" c_sdpStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -sdpStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpStruct__1" c_sdpStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -sdpStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpStruct__2" c_sdpStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -sdpStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdpStruct__3" c_sdpStruct__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdpStruct__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -sdpStruct__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdpStruct__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__0" c_sdqpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -sdqpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__1" c_sdqpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -sdqpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__2" c_sdqpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -sdqpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__3" c_sdqpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -sdqpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__4" c_sdqpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__5" c_sdqpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__6" c_sdqpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__7" c_sdqpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__8" c_sdqpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__9" c_sdqpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpIn__9 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__10" c_sdqpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__10 - :: Vector DMatrix -> IO (Vector DMatrix) -sdqpIn__10 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__10 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__11" c_sdqpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__11 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -sdqpIn__11 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__11 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__12" c_sdqpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__12 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -sdqpIn__12 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__12 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__13" c_sdqpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__13 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -sdqpIn__13 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__13 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__14" c_sdqpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__14 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpIn__14 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__14 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__15" c_sdqpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpIn__15 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__16" c_sdqpIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__16 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpIn__16 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__17" c_sdqpIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__18" c_sdqpIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__18 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__19" c_sdqpIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpIn__19 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__20" c_sdqpIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__20 - :: Vector MX -> IO (Vector MX) -sdqpIn__20 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__20 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__21" c_sdqpIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__21 - :: Vector MX -> String -> IO (Vector MX) -sdqpIn__21 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__21 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__22" c_sdqpIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__22 - :: Vector MX -> String -> String -> IO (Vector MX) -sdqpIn__22 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__22 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__23" c_sdqpIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__23 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -sdqpIn__23 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__23 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__24" c_sdqpIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__24 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -sdqpIn__24 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__24 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__25" c_sdqpIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__25 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpIn__25 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__26" c_sdqpIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__26 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpIn__26 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__27" c_sdqpIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__27 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__28" c_sdqpIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__28 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__29" c_sdqpIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpIn__29 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__30" c_sdqpIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__30 - :: Vector SX -> IO (Vector SX) -sdqpIn__30 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__30 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__31" c_sdqpIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__31 - :: Vector SX -> String -> IO (Vector SX) -sdqpIn__31 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__31 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__32" c_sdqpIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__32 - :: Vector SX -> String -> String -> IO (Vector SX) -sdqpIn__32 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__32 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__33" c_sdqpIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__33 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -sdqpIn__33 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__33 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__34" c_sdqpIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__34 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -sdqpIn__34 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__34 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__35" c_sdqpIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__35 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpIn__35 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__36" c_sdqpIn__36 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__36 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpIn__36 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__37" c_sdqpIn__37 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__37 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__38" c_sdqpIn__38 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__38 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpIn__39" c_sdqpIn__39 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpIn__39 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__0" c_sdqpOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -sdqpOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__1" c_sdqpOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -sdqpOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__2" c_sdqpOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -sdqpOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__3" c_sdqpOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -sdqpOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__4" c_sdqpOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__5" c_sdqpOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpOut__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__6" c_sdqpOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpOut__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__7" c_sdqpOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpOut__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__8" c_sdqpOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__8 - :: Vector DMatrix -> IO (Vector DMatrix) -sdqpOut__8 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__8 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__9" c_sdqpOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__9 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -sdqpOut__9 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__9 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__10" c_sdqpOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__10 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -sdqpOut__10 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__10 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__11" c_sdqpOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__11 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -sdqpOut__11 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__11 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__12" c_sdqpOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__12 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpOut__12 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__12 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__13" c_sdqpOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpOut__13 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__14" c_sdqpOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__14 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpOut__14 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__15" c_sdqpOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -sdqpOut__15 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -sdqpOut__15 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__16" c_sdqpOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__16 - :: Vector MX -> IO (Vector MX) -sdqpOut__16 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__16 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__17" c_sdqpOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__17 - :: Vector MX -> String -> IO (Vector MX) -sdqpOut__17 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__17 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__18" c_sdqpOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__18 - :: Vector MX -> String -> String -> IO (Vector MX) -sdqpOut__18 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__18 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__19" c_sdqpOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__19 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -sdqpOut__19 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__19 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__20" c_sdqpOut__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__20 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -sdqpOut__20 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__20 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__21" c_sdqpOut__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__21 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpOut__21 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__22" c_sdqpOut__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__22 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpOut__22 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__23" c_sdqpOut__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -sdqpOut__23 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -sdqpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__24" c_sdqpOut__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__24 - :: Vector SX -> IO (Vector SX) -sdqpOut__24 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__24 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__25" c_sdqpOut__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__25 - :: Vector SX -> String -> IO (Vector SX) -sdqpOut__25 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__25 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__26" c_sdqpOut__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__26 - :: Vector SX -> String -> String -> IO (Vector SX) -sdqpOut__26 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__26 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__27" c_sdqpOut__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__27 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -sdqpOut__27 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__27 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__28" c_sdqpOut__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__28 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -sdqpOut__28 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__28 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__29" c_sdqpOut__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__29 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpOut__29 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__30" c_sdqpOut__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__30 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpOut__30 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpOut__31" c_sdqpOut__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -sdqpOut__31 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -sdqpOut__31 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpStruct__0" c_sdqpStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -sdqpStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpStruct__1" c_sdqpStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -sdqpStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpStruct__2" c_sdqpStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -sdqpStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpStruct__3" c_sdqpStruct__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpStruct__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -sdqpStruct__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpStruct__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "sdqpStruct__4" c_sdqpStruct__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -sdqpStruct__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -sdqpStruct__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_sdqpStruct__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleIRK__0" c_simpleIRK__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') -simpleIRK__0 - :: Function -> IO MXFunction -simpleIRK__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleIRK__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleIRK__1" c_simpleIRK__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MXFunction') -simpleIRK__1 - :: Function -> Int -> IO MXFunction -simpleIRK__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleIRK__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleIRK__2" c_simpleIRK__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MXFunction') -simpleIRK__2 - :: Function -> Int -> Int -> IO MXFunction -simpleIRK__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleIRK__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleIRK__3" c_simpleIRK__3 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> IO (Ptr MXFunction') -simpleIRK__3 - :: Function -> Int -> Int -> String -> IO MXFunction -simpleIRK__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleIRK__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleIRK__4" c_simpleIRK__4 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> Ptr StdString -> IO (Ptr MXFunction') -simpleIRK__4 - :: Function -> Int -> Int -> String -> String -> IO MXFunction -simpleIRK__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleIRK__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleIntegrator__0" c_simpleIntegrator__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') -simpleIntegrator__0 - :: Function -> IO MXFunction -simpleIntegrator__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleIntegrator__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleIntegrator__1" c_simpleIntegrator__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MXFunction') -simpleIntegrator__1 - :: Function -> String -> IO MXFunction -simpleIntegrator__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleIntegrator__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleRK__0" c_simpleRK__0 - :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') -simpleRK__0 - :: Function -> IO MXFunction -simpleRK__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleRK__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleRK__1" c_simpleRK__1 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MXFunction') -simpleRK__1 - :: Function -> Int -> IO MXFunction -simpleRK__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleRK__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "simpleRK__2" c_simpleRK__2 - :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MXFunction') -simpleRK__2 - :: Function -> Int -> Int -> IO MXFunction -simpleRK__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_simpleRK__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__0" c_socpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -socpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__1" c_socpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -socpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__2" c_socpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -socpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__3" c_socpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -socpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__4" c_socpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -socpIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__5" c_socpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__6" c_socpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__7" c_socpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__8" c_socpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__9" c_socpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__9 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__10" c_socpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpIn__10 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__11" c_socpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__11 - :: Vector DMatrix -> IO (Vector DMatrix) -socpIn__11 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__11 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__12" c_socpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__12 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -socpIn__12 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__12 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__13" c_socpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__13 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -socpIn__13 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__13 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__14" c_socpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__14 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -socpIn__14 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__14 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__15" c_socpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__15 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -socpIn__15 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__15 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__16" c_socpIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__16 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpIn__16 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__17" c_socpIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpIn__17 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__18" c_socpIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__18 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__19" c_socpIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__19 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__20" c_socpIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__20 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__21" c_socpIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpIn__21 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__22" c_socpIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__22 - :: Vector MX -> IO (Vector MX) -socpIn__22 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__22 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__23" c_socpIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__23 - :: Vector MX -> String -> IO (Vector MX) -socpIn__23 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__23 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__24" c_socpIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__24 - :: Vector MX -> String -> String -> IO (Vector MX) -socpIn__24 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__24 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__25" c_socpIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__25 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -socpIn__25 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__25 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__26" c_socpIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__26 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -socpIn__26 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__26 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__27" c_socpIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__27 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -socpIn__27 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__28" c_socpIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__28 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -socpIn__28 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__29" c_socpIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__29 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -socpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__30" c_socpIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__30 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -socpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__31" c_socpIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__31 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -socpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__32" c_socpIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpIn__32 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -socpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__33" c_socpIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__33 - :: Vector SX -> IO (Vector SX) -socpIn__33 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__33 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__34" c_socpIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__34 - :: Vector SX -> String -> IO (Vector SX) -socpIn__34 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__34 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__35" c_socpIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__35 - :: Vector SX -> String -> String -> IO (Vector SX) -socpIn__35 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__35 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__36" c_socpIn__36 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__36 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -socpIn__36 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__36 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__37" c_socpIn__37 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__37 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -socpIn__37 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__37 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__38" c_socpIn__38 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__38 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -socpIn__38 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__39" c_socpIn__39 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__39 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -socpIn__39 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__40" c_socpIn__40 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__40 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -socpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__41" c_socpIn__41 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__41 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -socpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__42" c_socpIn__42 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__42 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -socpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpIn__43" c_socpIn__43 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpIn__43 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -socpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__0" c_socpOut__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpOut__0 - :: Vector Sparsity -> IO (Vector Sparsity) -socpOut__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__1" c_socpOut__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpOut__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -socpOut__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__2" c_socpOut__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpOut__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -socpOut__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__3" c_socpOut__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpOut__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -socpOut__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__4" c_socpOut__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpOut__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -socpOut__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__5" c_socpOut__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpOut__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpOut__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__6" c_socpOut__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpOut__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -socpOut__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__7" c_socpOut__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpOut__7 - :: Vector DMatrix -> IO (Vector DMatrix) -socpOut__7 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__7 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__8" c_socpOut__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpOut__8 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -socpOut__8 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__8 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__9" c_socpOut__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpOut__9 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -socpOut__9 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__9 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__10" c_socpOut__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpOut__10 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -socpOut__10 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__10 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__11" c_socpOut__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpOut__11 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -socpOut__11 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__11 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__12" c_socpOut__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpOut__12 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpOut__12 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__13" c_socpOut__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -socpOut__13 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -socpOut__13 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__14" c_socpOut__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -socpOut__14 - :: Vector MX -> IO (Vector MX) -socpOut__14 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__14 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__15" c_socpOut__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpOut__15 - :: Vector MX -> String -> IO (Vector MX) -socpOut__15 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__15 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__16" c_socpOut__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpOut__16 - :: Vector MX -> String -> String -> IO (Vector MX) -socpOut__16 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__16 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__17" c_socpOut__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpOut__17 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -socpOut__17 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__17 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__18" c_socpOut__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpOut__18 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -socpOut__18 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__18 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__19" c_socpOut__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpOut__19 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -socpOut__19 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__20" c_socpOut__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -socpOut__20 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -socpOut__20 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__21" c_socpOut__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -socpOut__21 - :: Vector SX -> IO (Vector SX) -socpOut__21 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__21 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__22" c_socpOut__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpOut__22 - :: Vector SX -> String -> IO (Vector SX) -socpOut__22 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__22 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__23" c_socpOut__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpOut__23 - :: Vector SX -> String -> String -> IO (Vector SX) -socpOut__23 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__23 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__24" c_socpOut__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpOut__24 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -socpOut__24 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__24 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__25" c_socpOut__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpOut__25 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -socpOut__25 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__25 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__26" c_socpOut__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpOut__26 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -socpOut__26 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpOut__27" c_socpOut__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -socpOut__27 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -socpOut__27 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpStruct__0" c_socpStruct__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpStruct__0 - :: Vector Sparsity -> IO (Vector Sparsity) -socpStruct__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpStruct__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpStruct__1" c_socpStruct__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpStruct__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -socpStruct__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpStruct__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpStruct__2" c_socpStruct__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpStruct__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -socpStruct__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpStruct__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "socpStruct__3" c_socpStruct__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -socpStruct__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -socpStruct__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_socpStruct__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "solve__0" c_solve__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -solve__0 - :: MX -> MX -> IO MX -solve__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_solve__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "solve__1" c_solve__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') -solve__1 - :: MX -> MX -> String -> IO MX -solve__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_solve__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "solve__2" c_solve__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -solve__2 - :: SX -> SX -> IO SX -solve__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_solve__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "solve__3" c_solve__3 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') -solve__3 - :: DMatrix -> DMatrix -> IO DMatrix -solve__3 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_solve__3 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "solve__4" c_solve__4 - :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') -solve__4 - :: IMatrix -> IMatrix -> IO IMatrix -solve__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_solve__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "solve__5" c_solve__5 - :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix') -solve__5 - :: DMatrix -> DMatrix -> String -> IO DMatrix -solve__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_solve__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "spy" c_spy - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -spy - :: SX -> IO SX -spy x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_spy errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__0" c_stabilizedQpIn__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__0 - :: Vector Sparsity -> IO (Vector Sparsity) -stabilizedQpIn__0 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__0 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__1" c_stabilizedQpIn__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__1 - :: Vector Sparsity -> String -> IO (Vector Sparsity) -stabilizedQpIn__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__2" c_stabilizedQpIn__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__2 - :: Vector Sparsity -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__3" c_stabilizedQpIn__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__3 - :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__3 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__3 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__4" c_stabilizedQpIn__4 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__4 - :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__4 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__4 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__5" c_stabilizedQpIn__5 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__5 - :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__5 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__6" c_stabilizedQpIn__6 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__6 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__6 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__7" c_stabilizedQpIn__7 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__7 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__8" c_stabilizedQpIn__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__8 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__9" c_stabilizedQpIn__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__9 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__10" c_stabilizedQpIn__10 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__10 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__11" c_stabilizedQpIn__11 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__11 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__12" c_stabilizedQpIn__12 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity'))) -stabilizedQpIn__12 - :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity) -stabilizedQpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__13" c_stabilizedQpIn__13 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__13 - :: Vector DMatrix -> IO (Vector DMatrix) -stabilizedQpIn__13 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__13 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__14" c_stabilizedQpIn__14 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__14 - :: Vector DMatrix -> String -> IO (Vector DMatrix) -stabilizedQpIn__14 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__14 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__15" c_stabilizedQpIn__15 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__15 - :: Vector DMatrix -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__15 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__15 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__16" c_stabilizedQpIn__16 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__16 - :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__16 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__16 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__17" c_stabilizedQpIn__17 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__17 - :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__17 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__17 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__18" c_stabilizedQpIn__18 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__18 - :: Vector DMatrix -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__18 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__19" c_stabilizedQpIn__19 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__19 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__19 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__20" c_stabilizedQpIn__20 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__20 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__21" c_stabilizedQpIn__21 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__21 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__22" c_stabilizedQpIn__22 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__22 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__23" c_stabilizedQpIn__23 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__23 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__24" c_stabilizedQpIn__24 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__24 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__25" c_stabilizedQpIn__25 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix'))) -stabilizedQpIn__25 - :: Vector DMatrix -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector DMatrix) -stabilizedQpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__26" c_stabilizedQpIn__26 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__26 - :: Vector MX -> IO (Vector MX) -stabilizedQpIn__26 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__26 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__27" c_stabilizedQpIn__27 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__27 - :: Vector MX -> String -> IO (Vector MX) -stabilizedQpIn__27 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__27 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__28" c_stabilizedQpIn__28 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__28 - :: Vector MX -> String -> String -> IO (Vector MX) -stabilizedQpIn__28 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__28 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__29" c_stabilizedQpIn__29 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__29 - :: Vector MX -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__29 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__29 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__30" c_stabilizedQpIn__30 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__30 - :: Vector MX -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__30 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__30 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__31" c_stabilizedQpIn__31 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__31 - :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__31 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__32" c_stabilizedQpIn__32 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__32 - :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__32 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__33" c_stabilizedQpIn__33 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__33 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__34" c_stabilizedQpIn__34 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__34 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__35" c_stabilizedQpIn__35 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__35 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__36" c_stabilizedQpIn__36 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__36 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__37" c_stabilizedQpIn__37 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__37 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__38" c_stabilizedQpIn__38 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX'))) -stabilizedQpIn__38 - :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX) -stabilizedQpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__39" c_stabilizedQpIn__39 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__39 - :: Vector SX -> IO (Vector SX) -stabilizedQpIn__39 x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__39 errStrPtrP x0' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__40" c_stabilizedQpIn__40 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__40 - :: Vector SX -> String -> IO (Vector SX) -stabilizedQpIn__40 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__40 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__41" c_stabilizedQpIn__41 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__41 - :: Vector SX -> String -> String -> IO (Vector SX) -stabilizedQpIn__41 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__41 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__42" c_stabilizedQpIn__42 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__42 - :: Vector SX -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__42 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__42 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__43" c_stabilizedQpIn__43 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__43 - :: Vector SX -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__43 x0 x1 x2 x3 x4 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__43 errStrPtrP x0' x1' x2' x3' x4' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__44" c_stabilizedQpIn__44 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__44 - :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__44 x0 x1 x2 x3 x4 x5 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__45" c_stabilizedQpIn__45 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__45 - :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__45 x0 x1 x2 x3 x4 x5 x6 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__46" c_stabilizedQpIn__46 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__46 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__47" c_stabilizedQpIn__47 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__47 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__48" c_stabilizedQpIn__48 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__48 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__49" c_stabilizedQpIn__49 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__49 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__50" c_stabilizedQpIn__50 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__50 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "stabilizedQpIn__51" c_stabilizedQpIn__51 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX'))) -stabilizedQpIn__51 - :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX) -stabilizedQpIn__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - withMarshal x4 $ \x4' -> - withMarshal x5 $ \x5' -> - withMarshal x6 $ \x6' -> - withMarshal x7 $ \x7' -> - withMarshal x8 $ \x8' -> - withMarshal x9 $ \x9' -> - withMarshal x10 $ \x10' -> - withMarshal x11 $ \x11' -> - withMarshal x12 $ \x12' -> - do - errStrPtrP <- new nullPtr - ret <- c_stabilizedQpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substitute__0" c_substitute__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) -substitute__0 - :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) -substitute__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substitute__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substitute__1" c_substitute__1 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -substitute__1 - :: MX -> MX -> MX -> IO MX -substitute__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substitute__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substitute__2" c_substitute__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) -substitute__2 - :: Vector SX -> Vector SX -> Vector SX -> IO (Vector SX) -substitute__2 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substitute__2 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substitute__3" c_substitute__3 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -substitute__3 - :: SX -> SX -> SX -> IO SX -substitute__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substitute__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__0" c_substituteInPlace__0 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () -substituteInPlace__0 - :: Vector MX -> Vector MX -> Vector MX -> IO () -substituteInPlace__0 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__0 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__1" c_substituteInPlace__1 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () -substituteInPlace__1 - :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO () -substituteInPlace__1 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__1 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__2" c_substituteInPlace__2 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () -substituteInPlace__2 - :: Vector MX -> Vector MX -> IO () -substituteInPlace__2 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__2 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__3" c_substituteInPlace__3 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () -substituteInPlace__3 - :: Vector MX -> Vector MX -> Bool -> IO () -substituteInPlace__3 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__3 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__4" c_substituteInPlace__4 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO () -substituteInPlace__4 - :: SX -> SX -> IO () -substituteInPlace__4 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__4 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__5" c_substituteInPlace__5 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO () -substituteInPlace__5 - :: SX -> SX -> Bool -> IO () -substituteInPlace__5 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__5 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__6" c_substituteInPlace__6 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> IO () -substituteInPlace__6 - :: SX -> SX -> Vector SX -> IO () -substituteInPlace__6 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__6 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__7" c_substituteInPlace__7 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO () -substituteInPlace__7 - :: SX -> SX -> Vector SX -> Bool -> IO () -substituteInPlace__7 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__7 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__8" c_substituteInPlace__8 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () -substituteInPlace__8 - :: Vector SX -> Vector SX -> Vector SX -> IO () -substituteInPlace__8 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__8 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "substituteInPlace__9" c_substituteInPlace__9 - :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO () -substituteInPlace__9 - :: Vector SX -> Vector SX -> Vector SX -> Bool -> IO () -substituteInPlace__9 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_substituteInPlace__9 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "tangent__0" c_tangent__0 - :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') -tangent__0 - :: MX -> MX -> IO MX -tangent__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_tangent__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "tangent__1" c_tangent__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -tangent__1 - :: SX -> SX -> IO SX -tangent__1 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_tangent__1 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "taylor__0" c_taylor__0 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -taylor__0 - :: SX -> SX -> IO SX -taylor__0 x0 x1 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - do - errStrPtrP <- new nullPtr - ret <- c_taylor__0 errStrPtrP x0' x1' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "taylor__1" c_taylor__1 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') -taylor__1 - :: SX -> SX -> SX -> IO SX -taylor__1 x0 x1 x2 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - do - errStrPtrP <- new nullPtr - ret <- c_taylor__1 errStrPtrP x0' x1' x2' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "taylor__2" c_taylor__2 - :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') -taylor__2 - :: SX -> SX -> SX -> Int -> IO SX -taylor__2 x0 x1 x2 x3 = - withMarshal x0 $ \x0' -> - withMarshal x1 $ \x1' -> - withMarshal x2 $ \x2' -> - withMarshal x3 $ \x3' -> - do - errStrPtrP <- new nullPtr - ret <- c_taylor__2 errStrPtrP x0' x1' x2' x3' - errStrPtr <- peek errStrPtrP - free errStrPtrP - if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) - - -foreign import ccall unsafe "triangle" c_triangle - :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') -triangle - :: SX -> IO SX -triangle x0 = - withMarshal x0 $ \x0' -> - do - errStrPtrP <- new nullPtr - ret <- c_triangle errStrPtrP x0' + casadi_abs__0, + casadi_abs__1, + casadi_abs__2, + casadi_abs__3, + casadi_acos__0, + casadi_acos__1, + casadi_acos__2, + casadi_acos__3, + casadi_acosh__0, + casadi_acosh__1, + casadi_acosh__2, + casadi_acosh__3, + casadi_adj__0, + casadi_adj__1, + casadi_adj__2, + casadi_all__0, + casadi_all__1, + casadi_all__2, + casadi_and__0, + casadi_and__1, + casadi_and__2, + casadi_and__3, + casadi_any__0, + casadi_any__1, + casadi_any__2, + casadi_asin__0, + casadi_asin__1, + casadi_asin__2, + casadi_asin__3, + casadi_asinh__0, + casadi_asinh__1, + casadi_asinh__2, + casadi_asinh__3, + casadi_atan2__0, + casadi_atan2__1, + casadi_atan2__2, + casadi_atan2__3, + casadi_atan__0, + casadi_atan__1, + casadi_atan__2, + casadi_atan__3, + casadi_atanh__0, + casadi_atanh__1, + casadi_atanh__2, + casadi_atanh__3, + casadi_blockcat__0, + casadi_blockcat__1, + casadi_blockcat__2, + casadi_blockcat__3, + casadi_blockcat__4, + casadi_blockcat__5, + casadi_blockcat__6, + casadi_blockcat__7, + casadi_blockcat__8, + casadi_blockcat__9, + casadi_blocksplit__0, + casadi_blocksplit__1, + casadi_blocksplit__10, + casadi_blocksplit__11, + casadi_blocksplit__12, + casadi_blocksplit__13, + casadi_blocksplit__14, + casadi_blocksplit__15, + casadi_blocksplit__16, + casadi_blocksplit__17, + casadi_blocksplit__18, + casadi_blocksplit__19, + casadi_blocksplit__2, + casadi_blocksplit__3, + casadi_blocksplit__4, + casadi_blocksplit__5, + casadi_blocksplit__6, + casadi_blocksplit__7, + casadi_blocksplit__8, + casadi_blocksplit__9, + casadi_ceil__0, + casadi_ceil__1, + casadi_ceil__2, + casadi_ceil__3, + casadi_chol__0, + casadi_chol__1, + casadi_chol__2, + casadi_cofactor__0, + casadi_cofactor__1, + casadi_cofactor__2, + casadi_conditional__0, + casadi_conditional__1, + casadi_conditional__2, + casadi_conditional__3, + casadi_conditional__4, + casadi_conditional__5, + casadi_conditional__6, + casadi_conditional__7, + casadi_constpow__0, + casadi_constpow__1, + casadi_constpow__2, + casadi_constpow__3, + casadi_copysign__0, + casadi_copysign__1, + casadi_copysign__2, + casadi_copysign__3, + casadi_cos__0, + casadi_cos__1, + casadi_cos__2, + casadi_cos__3, + casadi_cosh__0, + casadi_cosh__1, + casadi_cosh__2, + casadi_cosh__3, + casadi_countNodes__0, + casadi_countNodes__1, + casadi_countNodes__2, + casadi_countNodes__3, + casadi_cross__0, + casadi_cross__1, + casadi_cross__2, + casadi_cross__3, + casadi_cross__4, + casadi_cross__5, + casadi_cross__6, + casadi_cross__7, + casadi_densify__0, + casadi_densify__1, + casadi_densify__2, + casadi_densify__3, + casadi_dependsOn__0, + casadi_dependsOn__1, + casadi_dependsOn__2, + casadi_dependsOn__3, + casadi_det__0, + casadi_det__1, + casadi_det__2, + casadi_det__3, + casadi_diag__0, + casadi_diag__1, + casadi_diag__2, + casadi_diag__3, + casadi_diagcat__0, + casadi_diagcat__1, + casadi_diagcat__2, + casadi_diagcat__3, + casadi_diagcat__4, + casadi_diagsplit__0, + casadi_diagsplit__1, + casadi_diagsplit__10, + casadi_diagsplit__11, + casadi_diagsplit__12, + casadi_diagsplit__13, + casadi_diagsplit__14, + casadi_diagsplit__15, + casadi_diagsplit__16, + casadi_diagsplit__17, + casadi_diagsplit__18, + casadi_diagsplit__19, + casadi_diagsplit__2, + casadi_diagsplit__20, + casadi_diagsplit__21, + casadi_diagsplit__22, + casadi_diagsplit__23, + casadi_diagsplit__24, + casadi_diagsplit__3, + casadi_diagsplit__4, + casadi_diagsplit__5, + casadi_diagsplit__6, + casadi_diagsplit__7, + casadi_diagsplit__8, + casadi_diagsplit__9, + casadi_eig_symbolic__0, + casadi_eig_symbolic__1, + casadi_eig_symbolic__2, + casadi_eq__0, + casadi_eq__1, + casadi_eq__2, + casadi_eq__3, + casadi_erf__0, + casadi_erf__1, + casadi_erf__2, + casadi_erf__3, + casadi_erfinv__0, + casadi_erfinv__1, + casadi_erfinv__2, + casadi_erfinv__3, + casadi_exp__0, + casadi_exp__1, + casadi_exp__2, + casadi_exp__3, + casadi_expand__0, + casadi_expand__1, + casadi_expand__2, + casadi_extractShared__0, + casadi_extractShared__1, + casadi_extractShared__10, + casadi_extractShared__11, + casadi_extractShared__2, + casadi_extractShared__3, + casadi_extractShared__4, + casadi_extractShared__5, + casadi_extractShared__6, + casadi_extractShared__7, + casadi_extractShared__8, + casadi_extractShared__9, + casadi_find, + casadi_floor__0, + casadi_floor__1, + casadi_floor__2, + casadi_floor__3, + casadi_gauss_quadrature__0, + casadi_gauss_quadrature__1, + casadi_gauss_quadrature__2, + casadi_gauss_quadrature__3, + casadi_gauss_quadrature__4, + casadi_gauss_quadrature__5, + casadi_gauss_quadrature__6, + casadi_gauss_quadrature__7, + casadi_gauss_quadrature__8, + casadi_ge__0, + casadi_ge__1, + casadi_ge__2, + casadi_ge__3, + casadi_getMinor__0, + casadi_getMinor__1, + casadi_getMinor__2, + casadi_getOperatorRepresentation__0, + casadi_getOperatorRepresentation__1, + casadi_getOperatorRepresentation__2, + casadi_getOperatorRepresentation__3, + casadi_gradient__0, + casadi_gradient__1, + casadi_gradient__2, + casadi_gradient__3, + casadi_graph_substitute__0, + casadi_graph_substitute__1, + casadi_gt__0, + casadi_gt__1, + casadi_gt__2, + casadi_gt__3, + casadi_heaviside__0, + casadi_heaviside__1, + casadi_heaviside__2, + casadi_hessian__0, + casadi_hessian__1, + casadi_hessian__2, + casadi_hessian__3, + casadi_horzcat__0, + casadi_horzcat__1, + casadi_horzcat__2, + casadi_horzcat__3, + casadi_horzcat__4, + casadi_horzsplit__0, + casadi_horzsplit__1, + casadi_horzsplit__10, + casadi_horzsplit__11, + casadi_horzsplit__12, + casadi_horzsplit__13, + casadi_horzsplit__14, + casadi_horzsplit__2, + casadi_horzsplit__3, + casadi_horzsplit__4, + casadi_horzsplit__5, + casadi_horzsplit__6, + casadi_horzsplit__7, + casadi_horzsplit__8, + casadi_horzsplit__9, + casadi_if_else__0, + casadi_if_else__1, + casadi_if_else__2, + casadi_if_else__3, + casadi_if_else__4, + casadi_if_else__5, + casadi_if_else__6, + casadi_if_else__7, + casadi_inner_prod__0, + casadi_inner_prod__1, + casadi_inner_prod__2, + casadi_inner_prod__3, + casadi_inv__0, + casadi_inv__1, + casadi_inv__2, + casadi_inv__3, + casadi_isEqual__0, + casadi_isEqual__1, + casadi_isEqual__2, + casadi_isEqual__3, + casadi_isEqual__4, + casadi_isEqual__5, + casadi_isEqual__6, + casadi_isEqual__7, + casadi_iszero__0, + casadi_iszero__1, + casadi_iszero__2, + casadi_iszero__3, + casadi_jacobianTimesVector__0, + casadi_jacobianTimesVector__1, + casadi_jacobianTimesVector__2, + casadi_jacobianTimesVector__3, + casadi_jacobianTimesVector__4, + casadi_jacobianTimesVector__5, + casadi_jacobian__0, + casadi_jacobian__1, + casadi_jacobian__2, + casadi_jacobian__3, + casadi_kron__0, + casadi_kron__1, + casadi_kron__2, + casadi_kron__3, + casadi_kron__4, + casadi_ldivide__0, + casadi_ldivide__1, + casadi_ldivide__2, + casadi_ldivide__3, + casadi_le__0, + casadi_le__1, + casadi_le__2, + casadi_le__3, + casadi_linspace__0, + casadi_linspace__1, + casadi_linspace__2, + casadi_linspace__3, + casadi_log10__0, + casadi_log10__1, + casadi_log10__2, + casadi_log10__3, + casadi_log__0, + casadi_log__1, + casadi_log__2, + casadi_log__3, + casadi_lt__0, + casadi_lt__1, + casadi_lt__2, + casadi_lt__3, + casadi_mac__0, + casadi_mac__1, + casadi_mac__2, + casadi_mac__3, + casadi_mac__4, + casadi_matrix_expand__0, + casadi_matrix_expand__1, + casadi_matrix_expand__2, + casadi_matrix_expand__3, + casadi_matrix_expand__4, + casadi_matrix_expand__5, + casadi_max__0, + casadi_max__1, + casadi_max__2, + casadi_max__3, + casadi_min__0, + casadi_min__1, + casadi_min__2, + casadi_min__3, + casadi_minus__0, + casadi_minus__1, + casadi_minus__2, + casadi_minus__3, + casadi_mldivide__0, + casadi_mldivide__1, + casadi_mldivide__2, + casadi_mldivide__3, + casadi_mod__0, + casadi_mod__1, + casadi_mod__2, + casadi_mod__3, + casadi_mpower__0, + casadi_mpower__1, + casadi_mpower__2, + casadi_mpower__3, + casadi_mrdivide__0, + casadi_mrdivide__1, + casadi_mrdivide__2, + casadi_mrdivide__3, + casadi_mtaylor__0, + casadi_mtaylor__1, + casadi_mtaylor__2, + casadi_mtaylor__3, + casadi_mtaylor__4, + casadi_mtaylor__5, + casadi_mtaylor__6, + casadi_mtaylor__7, + casadi_mtaylor__8, + casadi_mul__0, + casadi_mul__1, + casadi_mul__2, + casadi_mul__3, + casadi_mul__4, + casadi_mul__5, + casadi_mul__6, + casadi_mul__7, + casadi_mul__8, + casadi_mul__9, + casadi_ne__0, + casadi_ne__1, + casadi_ne__2, + casadi_ne__3, + casadi_norm_0_mul__0, + casadi_norm_0_mul__1, + casadi_norm_0_mul__2, + casadi_norm_0_mul__3, + casadi_norm_0_mul__4, + casadi_norm_1__0, + casadi_norm_1__1, + casadi_norm_1__2, + casadi_norm_1__3, + casadi_norm_2__0, + casadi_norm_2__1, + casadi_norm_2__2, + casadi_norm_2__3, + casadi_norm_F__0, + casadi_norm_F__1, + casadi_norm_F__2, + casadi_norm_F__3, + casadi_norm_inf__0, + casadi_norm_inf__1, + casadi_norm_inf__2, + casadi_norm_inf__3, + casadi_norm_inf_mul__0, + casadi_norm_inf_mul__1, + casadi_norm_inf_mul__2, + casadi_not__0, + casadi_not__1, + casadi_not__2, + casadi_not__3, + casadi_nullspace__0, + casadi_nullspace__1, + casadi_nullspace__2, + casadi_nullspace__3, + casadi_offset__0, + casadi_offset__1, + casadi_offset__2, + casadi_offset__3, + casadi_offset__4, + casadi_offset__5, + casadi_offset__6, + casadi_offset__7, + casadi_offset__8, + casadi_offset__9, + casadi_or__0, + casadi_or__1, + casadi_or__2, + casadi_or__3, + casadi_outer_prod__0, + casadi_outer_prod__1, + casadi_outer_prod__2, + casadi_outer_prod__3, + casadi_pinv__0, + casadi_pinv__1, + casadi_pinv__10, + casadi_pinv__11, + casadi_pinv__2, + casadi_pinv__3, + casadi_pinv__4, + casadi_pinv__5, + casadi_pinv__6, + casadi_pinv__7, + casadi_pinv__8, + casadi_pinv__9, + casadi_plus__0, + casadi_plus__1, + casadi_plus__2, + casadi_plus__3, + casadi_poly_coeff__0, + casadi_poly_coeff__1, + casadi_poly_coeff__2, + casadi_poly_roots__0, + casadi_poly_roots__1, + casadi_poly_roots__2, + casadi_polyval__0, + casadi_polyval__1, + casadi_polyval__2, + casadi_polyval__3, + casadi_power__0, + casadi_power__1, + casadi_power__2, + casadi_power__3, + casadi_project__0, + casadi_project__1, + casadi_project__2, + casadi_project__3, + casadi_project__4, + casadi_project__5, + casadi_project__6, + casadi_project__7, + casadi_pw_const__0, + casadi_pw_const__1, + casadi_pw_const__2, + casadi_pw_lin__0, + casadi_pw_lin__1, + casadi_pw_lin__2, + casadi_qr__0, + casadi_qr__1, + casadi_qr__2, + casadi_quad_form__0, + casadi_quad_form__1, + casadi_quad_form__2, + casadi_quad_form__3, + casadi_quad_form__4, + casadi_quad_form__5, + casadi_quad_form__6, + casadi_quad_form__7, + casadi_ramp__0, + casadi_ramp__1, + casadi_ramp__2, + casadi_rdivide__0, + casadi_rdivide__1, + casadi_rdivide__2, + casadi_rdivide__3, + casadi_rectangle__0, + casadi_rectangle__1, + casadi_rectangle__2, + casadi_repmat__0, + casadi_repmat__1, + casadi_repmat__10, + casadi_repmat__11, + casadi_repmat__12, + casadi_repmat__13, + casadi_repmat__14, + casadi_repmat__2, + casadi_repmat__3, + casadi_repmat__4, + casadi_repmat__5, + casadi_repmat__6, + casadi_repmat__7, + casadi_repmat__8, + casadi_repmat__9, + casadi_repsum__0, + casadi_repsum__1, + casadi_repsum__2, + casadi_repsum__3, + casadi_repsum__4, + casadi_repsum__5, + casadi_repsum__6, + casadi_repsum__7, + casadi_reshape__0, + casadi_reshape__1, + casadi_reshape__10, + casadi_reshape__11, + casadi_reshape__12, + casadi_reshape__13, + casadi_reshape__14, + casadi_reshape__2, + casadi_reshape__3, + casadi_reshape__4, + casadi_reshape__5, + casadi_reshape__6, + casadi_reshape__7, + casadi_reshape__8, + casadi_reshape__9, + casadi_sign__0, + casadi_sign__1, + casadi_sign__2, + casadi_sign__3, + casadi_simplify__0, + casadi_simplify__1, + casadi_simplify__2, + casadi_simplify__3, + casadi_sin__0, + casadi_sin__1, + casadi_sin__2, + casadi_sin__3, + casadi_sinh__0, + casadi_sinh__1, + casadi_sinh__2, + casadi_sinh__3, + casadi_solve__0, + casadi_solve__1, + casadi_solve__10, + casadi_solve__11, + casadi_solve__2, + casadi_solve__3, + casadi_solve__4, + casadi_solve__5, + casadi_solve__6, + casadi_solve__7, + casadi_solve__8, + casadi_solve__9, + casadi_sparsify__0, + casadi_sparsify__1, + casadi_sparsify__2, + casadi_sparsify__3, + casadi_sparsify__4, + casadi_sparsify__5, + casadi_sprank__0, + casadi_sprank__1, + casadi_sprank__2, + casadi_sprank__3, + casadi_sprank__4, + casadi_sqrt__0, + casadi_sqrt__1, + casadi_sqrt__2, + casadi_sqrt__3, + casadi_substituteInPlace__0, + casadi_substituteInPlace__1, + casadi_substituteInPlace__2, + casadi_substituteInPlace__3, + casadi_substituteInPlace__4, + casadi_substituteInPlace__5, + casadi_substituteInPlace__6, + casadi_substituteInPlace__7, + casadi_substitute__0, + casadi_substitute__1, + casadi_substitute__2, + casadi_substitute__3, + casadi_substitute__4, + casadi_substitute__5, + casadi_substitute__6, + casadi_substitute__7, + casadi_sumCols__0, + casadi_sumCols__1, + casadi_sumCols__2, + casadi_sumCols__3, + casadi_sumRows__0, + casadi_sumRows__1, + casadi_sumRows__2, + casadi_sumRows__3, + casadi_sum_square__0, + casadi_sum_square__1, + casadi_sum_square__2, + casadi_sum_square__3, + casadi_symvar__0, + casadi_symvar__1, + casadi_symvar__2, + casadi_symvar__3, + casadi_tan__0, + casadi_tan__1, + casadi_tan__2, + casadi_tan__3, + casadi_tangent__0, + casadi_tangent__1, + casadi_tangent__2, + casadi_tangent__3, + casadi_tanh__0, + casadi_tanh__1, + casadi_tanh__2, + casadi_tanh__3, + casadi_taylor__0, + casadi_taylor__1, + casadi_taylor__2, + casadi_taylor__3, + casadi_taylor__4, + casadi_taylor__5, + casadi_taylor__6, + casadi_taylor__7, + casadi_taylor__8, + casadi_times__0, + casadi_times__1, + casadi_times__2, + casadi_times__3, + casadi_trace__0, + casadi_trace__1, + casadi_trace__2, + casadi_trace__3, + casadi_transpose__0, + casadi_transpose__1, + casadi_transpose__2, + casadi_transpose__3, + casadi_transpose__4, + casadi_triangle__0, + casadi_triangle__1, + casadi_triangle__2, + casadi_tril2symm__0, + casadi_tril2symm__1, + casadi_tril2symm__2, + casadi_tril2symm__3, + casadi_tril__0, + casadi_tril__1, + casadi_tril__2, + casadi_tril__3, + casadi_tril__4, + casadi_tril__5, + casadi_tril__6, + casadi_tril__7, + casadi_tril__8, + casadi_tril__9, + casadi_triu2symm__0, + casadi_triu2symm__1, + casadi_triu2symm__2, + casadi_triu2symm__3, + casadi_triu__0, + casadi_triu__1, + casadi_triu__2, + casadi_triu__3, + casadi_triu__4, + casadi_triu__5, + casadi_triu__6, + casadi_triu__7, + casadi_triu__8, + casadi_triu__9, + casadi_unite__0, + casadi_unite__1, + casadi_unite__2, + casadi_unite__3, + casadi_vecNZ__0, + casadi_vecNZ__1, + casadi_vecNZ__2, + casadi_vecNZ__3, + casadi_vecNZ__4, + casadi_vec__0, + casadi_vec__1, + casadi_vec__2, + casadi_vec__3, + casadi_vec__4, + casadi_veccat__0, + casadi_veccat__1, + casadi_veccat__2, + casadi_veccat__3, + casadi_veccat__4, + casadi_vertcat__0, + casadi_vertcat__1, + casadi_vertcat__2, + casadi_vertcat__3, + casadi_vertcat__4, + casadi_vertsplit__0, + casadi_vertsplit__1, + casadi_vertsplit__10, + casadi_vertsplit__11, + casadi_vertsplit__12, + casadi_vertsplit__13, + casadi_vertsplit__14, + casadi_vertsplit__2, + casadi_vertsplit__3, + casadi_vertsplit__4, + casadi_vertsplit__5, + casadi_vertsplit__6, + casadi_vertsplit__7, + casadi_vertsplit__8, + casadi_vertsplit__9, + cleIn__0, + cleIn__1, + cleIn__11, + cleIn__12, + cleIn__13, + cleIn__2, + cleIn__3, + cleIn__4, + cleIn__5, + cleIn__6, + cleIn__7, + cleIn__8, + cleOut__0, + cleOut__1, + cleOut__2, + cleOut__5, + collocationInterpolators, + collocationPoints__0, + collocationPoints__1, + complement, + controldaeIn__0, + controldaeIn__1, + controldaeIn__10, + controldaeIn__11, + controldaeIn__12, + controldaeIn__13, + controldaeIn__14, + controldaeIn__15, + controldaeIn__16, + controldaeIn__17, + controldaeIn__18, + controldaeIn__19, + controldaeIn__2, + controldaeIn__20, + controldaeIn__21, + controldaeIn__22, + controldaeIn__23, + controldaeIn__24, + controldaeIn__25, + controldaeIn__26, + controldaeIn__27, + controldaeIn__28, + controldaeIn__29, + controldaeIn__3, + controldaeIn__30, + controldaeIn__31, + controldaeIn__32, + controldaeIn__33, + controldaeIn__34, + controldaeIn__35, + controldaeIn__36, + controldaeIn__37, + controldaeIn__38, + controldaeIn__39, + controldaeIn__4, + controldaeIn__40, + controldaeIn__41, + controldaeIn__42, + controldaeIn__43, + controldaeIn__44, + controldaeIn__45, + controldaeIn__46, + controldaeIn__47, + controldaeIn__48, + controldaeIn__49, + controldaeIn__5, + controldaeIn__50, + controldaeIn__53, + controldaeIn__54, + controldaeIn__55, + controldaeIn__56, + controldaeIn__57, + controldaeIn__58, + controldaeIn__59, + controldaeIn__6, + controldaeIn__60, + controldaeIn__61, + controldaeIn__62, + controldaeIn__63, + controldaeIn__64, + controldaeIn__65, + controldaeIn__66, + controldaeIn__67, + controldaeIn__68, + controldaeIn__69, + controldaeIn__7, + controldaeIn__8, + controldaeIn__9, + controlsimulatorIn__0, + controlsimulatorIn__1, + controlsimulatorIn__10, + controlsimulatorIn__11, + controlsimulatorIn__12, + controlsimulatorIn__13, + controlsimulatorIn__14, + controlsimulatorIn__17, + controlsimulatorIn__18, + controlsimulatorIn__19, + controlsimulatorIn__2, + controlsimulatorIn__20, + controlsimulatorIn__21, + controlsimulatorIn__3, + controlsimulatorIn__4, + controlsimulatorIn__5, + controlsimulatorIn__6, + controlsimulatorIn__7, + controlsimulatorIn__8, + controlsimulatorIn__9, + daeIn__0, + daeIn__1, + daeIn__10, + daeIn__11, + daeIn__12, + daeIn__13, + daeIn__14, + daeIn__15, + daeIn__16, + daeIn__17, + daeIn__18, + daeIn__19, + daeIn__2, + daeIn__20, + daeIn__23, + daeIn__24, + daeIn__25, + daeIn__26, + daeIn__27, + daeIn__28, + daeIn__29, + daeIn__3, + daeIn__4, + daeIn__5, + daeIn__6, + daeIn__7, + daeIn__8, + daeIn__9, + daeOut__0, + daeOut__1, + daeOut__10, + daeOut__11, + daeOut__12, + daeOut__13, + daeOut__14, + daeOut__17, + daeOut__18, + daeOut__19, + daeOut__2, + daeOut__20, + daeOut__21, + daeOut__3, + daeOut__4, + daeOut__5, + daeOut__6, + daeOut__7, + daeOut__8, + daeOut__9, + dleIn__0, + dleIn__1, + dleIn__11, + dleIn__12, + dleIn__13, + dleIn__2, + dleIn__3, + dleIn__4, + dleIn__5, + dleIn__6, + dleIn__7, + dleIn__8, + dleOut__0, + dleOut__1, + dleOut__2, + dleOut__5, + dpleIn__0, + dpleIn__1, + dpleIn__11, + dpleIn__12, + dpleIn__13, + dpleIn__2, + dpleIn__3, + dpleIn__4, + dpleIn__5, + dpleIn__6, + dpleIn__7, + dpleIn__8, + dpleOut__0, + dpleOut__1, + dpleOut__2, + dpleOut__5, + getSchemeEntryDoc, + getSchemeEntryEnum, + getSchemeEntryEnumName, + getSchemeEntryName, + getSchemeEntryNames, + getSchemeName, + getSchemeSize, + gradFIn__0, + gradFIn__1, + gradFIn__11, + gradFIn__12, + gradFIn__13, + gradFIn__2, + gradFIn__3, + gradFIn__4, + gradFIn__5, + gradFIn__6, + gradFIn__7, + gradFIn__8, + gradFOut__0, + gradFOut__1, + gradFOut__10, + gradFOut__11, + gradFOut__12, + gradFOut__13, + gradFOut__14, + gradFOut__17, + gradFOut__18, + gradFOut__19, + gradFOut__2, + gradFOut__20, + gradFOut__21, + gradFOut__3, + gradFOut__4, + gradFOut__5, + gradFOut__6, + gradFOut__7, + gradFOut__8, + gradFOut__9, + hessLagIn__0, + hessLagIn__1, + hessLagIn__10, + hessLagIn__11, + hessLagIn__12, + hessLagIn__13, + hessLagIn__14, + hessLagIn__15, + hessLagIn__16, + hessLagIn__17, + hessLagIn__18, + hessLagIn__19, + hessLagIn__2, + hessLagIn__20, + hessLagIn__23, + hessLagIn__24, + hessLagIn__25, + hessLagIn__26, + hessLagIn__27, + hessLagIn__28, + hessLagIn__29, + hessLagIn__3, + hessLagIn__4, + hessLagIn__5, + hessLagIn__6, + hessLagIn__7, + hessLagIn__8, + hessLagIn__9, + hessLagOut__0, + hessLagOut__1, + hessLagOut__10, + hessLagOut__11, + hessLagOut__12, + hessLagOut__13, + hessLagOut__14, + hessLagOut__15, + hessLagOut__16, + hessLagOut__17, + hessLagOut__18, + hessLagOut__19, + hessLagOut__2, + hessLagOut__20, + hessLagOut__21, + hessLagOut__22, + hessLagOut__23, + hessLagOut__24, + hessLagOut__25, + hessLagOut__26, + hessLagOut__29, + hessLagOut__3, + hessLagOut__30, + hessLagOut__31, + hessLagOut__32, + hessLagOut__33, + hessLagOut__34, + hessLagOut__35, + hessLagOut__36, + hessLagOut__37, + hessLagOut__4, + hessLagOut__5, + hessLagOut__6, + hessLagOut__7, + hessLagOut__8, + hessLagOut__9, + hnlpIn__0, + hnlpIn__1, + hnlpIn__10, + hnlpIn__11, + hnlpIn__12, + hnlpIn__13, + hnlpIn__14, + hnlpIn__17, + hnlpIn__18, + hnlpIn__19, + hnlpIn__2, + hnlpIn__20, + hnlpIn__21, + hnlpIn__3, + hnlpIn__4, + hnlpIn__5, + hnlpIn__6, + hnlpIn__7, + hnlpIn__8, + hnlpIn__9, + iOScheme__0, + iOScheme__1, + iOScheme__10, + iOScheme__11, + iOScheme__12, + iOScheme__13, + iOScheme__14, + iOScheme__15, + iOScheme__16, + iOScheme__17, + iOScheme__18, + iOScheme__19, + iOScheme__2, + iOScheme__20, + iOScheme__21, + iOScheme__22, + iOScheme__23, + iOScheme__3, + iOScheme__4, + iOScheme__5, + iOScheme__6, + iOScheme__7, + iOScheme__8, + iOScheme__9, + integratorIn__0, + integratorIn__1, + integratorIn__10, + integratorIn__11, + integratorIn__12, + integratorIn__13, + integratorIn__14, + integratorIn__15, + integratorIn__16, + integratorIn__17, + integratorIn__18, + integratorIn__19, + integratorIn__2, + integratorIn__20, + integratorIn__21, + integratorIn__22, + integratorIn__23, + integratorIn__24, + integratorIn__25, + integratorIn__26, + integratorIn__27, + integratorIn__28, + integratorIn__29, + integratorIn__3, + integratorIn__30, + integratorIn__31, + integratorIn__32, + integratorIn__35, + integratorIn__36, + integratorIn__37, + integratorIn__38, + integratorIn__39, + integratorIn__4, + integratorIn__40, + integratorIn__41, + integratorIn__42, + integratorIn__43, + integratorIn__44, + integratorIn__45, + integratorIn__5, + integratorIn__6, + integratorIn__7, + integratorIn__8, + integratorIn__9, + integratorOut__0, + integratorOut__1, + integratorOut__10, + integratorOut__11, + integratorOut__12, + integratorOut__13, + integratorOut__14, + integratorOut__15, + integratorOut__16, + integratorOut__17, + integratorOut__18, + integratorOut__19, + integratorOut__2, + integratorOut__20, + integratorOut__21, + integratorOut__22, + integratorOut__23, + integratorOut__24, + integratorOut__25, + integratorOut__26, + integratorOut__27, + integratorOut__28, + integratorOut__29, + integratorOut__3, + integratorOut__30, + integratorOut__31, + integratorOut__32, + integratorOut__35, + integratorOut__36, + integratorOut__37, + integratorOut__38, + integratorOut__39, + integratorOut__4, + integratorOut__40, + integratorOut__41, + integratorOut__42, + integratorOut__43, + integratorOut__44, + integratorOut__45, + integratorOut__5, + integratorOut__6, + integratorOut__7, + integratorOut__8, + integratorOut__9, + jacGIn__0, + jacGIn__1, + jacGIn__11, + jacGIn__12, + jacGIn__13, + jacGIn__2, + jacGIn__3, + jacGIn__4, + jacGIn__5, + jacGIn__6, + jacGIn__7, + jacGIn__8, + jacGOut__0, + jacGOut__1, + jacGOut__10, + jacGOut__11, + jacGOut__12, + jacGOut__13, + jacGOut__14, + jacGOut__17, + jacGOut__18, + jacGOut__19, + jacGOut__2, + jacGOut__20, + jacGOut__21, + jacGOut__3, + jacGOut__4, + jacGOut__5, + jacGOut__6, + jacGOut__7, + jacGOut__8, + jacGOut__9, + linsolIn__0, + linsolIn__1, + linsolIn__11, + linsolIn__12, + linsolIn__13, + linsolIn__2, + linsolIn__3, + linsolIn__4, + linsolIn__5, + linsolIn__6, + linsolIn__7, + linsolIn__8, + linsolOut__0, + linsolOut__1, + linsolOut__2, + linsolOut__5, + lookupvector, + lpIn__0, + lpIn__1, + lpIn__10, + lpIn__11, + lpIn__12, + lpIn__13, + lpIn__14, + lpIn__15, + lpIn__16, + lpIn__17, + lpIn__18, + lpIn__19, + lpIn__2, + lpIn__20, + lpIn__21, + lpIn__22, + lpIn__23, + lpIn__24, + lpIn__25, + lpIn__26, + lpIn__27, + lpIn__28, + lpIn__29, + lpIn__3, + lpIn__30, + lpIn__31, + lpIn__32, + lpIn__35, + lpIn__36, + lpIn__37, + lpIn__38, + lpIn__39, + lpIn__4, + lpIn__40, + lpIn__41, + lpIn__42, + lpIn__43, + lpIn__44, + lpIn__45, + lpIn__5, + lpIn__6, + lpIn__7, + lpIn__8, + lpIn__9, + lpOut__0, + lpOut__1, + lpOut__10, + lpOut__11, + lpOut__12, + lpOut__13, + lpOut__14, + lpOut__15, + lpOut__16, + lpOut__17, + lpOut__18, + lpOut__19, + lpOut__2, + lpOut__20, + lpOut__23, + lpOut__24, + lpOut__25, + lpOut__26, + lpOut__27, + lpOut__28, + lpOut__29, + lpOut__3, + lpOut__4, + lpOut__5, + lpOut__6, + lpOut__7, + lpOut__8, + lpOut__9, + lrdleIn__0, + lrdleIn__1, + lrdleIn__10, + lrdleIn__11, + lrdleIn__12, + lrdleIn__13, + lrdleIn__14, + lrdleIn__15, + lrdleIn__16, + lrdleIn__17, + lrdleIn__18, + lrdleIn__19, + lrdleIn__2, + lrdleIn__20, + lrdleIn__23, + lrdleIn__24, + lrdleIn__25, + lrdleIn__26, + lrdleIn__27, + lrdleIn__28, + lrdleIn__29, + lrdleIn__3, + lrdleIn__4, + lrdleIn__5, + lrdleIn__6, + lrdleIn__7, + lrdleIn__8, + lrdleIn__9, + lrdleOut__0, + lrdleOut__1, + lrdleOut__2, + lrdleOut__5, + lrdpleIn__0, + lrdpleIn__1, + lrdpleIn__10, + lrdpleIn__11, + lrdpleIn__12, + lrdpleIn__13, + lrdpleIn__14, + lrdpleIn__15, + lrdpleIn__16, + lrdpleIn__17, + lrdpleIn__18, + lrdpleIn__19, + lrdpleIn__2, + lrdpleIn__20, + lrdpleIn__23, + lrdpleIn__24, + lrdpleIn__25, + lrdpleIn__26, + lrdpleIn__27, + lrdpleIn__28, + lrdpleIn__29, + lrdpleIn__3, + lrdpleIn__4, + lrdpleIn__5, + lrdpleIn__6, + lrdpleIn__7, + lrdpleIn__8, + lrdpleIn__9, + lrdpleOut__0, + lrdpleOut__1, + lrdpleOut__2, + lrdpleOut__5, + nlpIn__0, + nlpIn__1, + nlpIn__11, + nlpIn__12, + nlpIn__13, + nlpIn__2, + nlpIn__3, + nlpIn__4, + nlpIn__5, + nlpIn__6, + nlpIn__7, + nlpIn__8, + nlpOut__0, + nlpOut__1, + nlpOut__11, + nlpOut__12, + nlpOut__13, + nlpOut__2, + nlpOut__3, + nlpOut__4, + nlpOut__5, + nlpOut__6, + nlpOut__7, + nlpOut__8, + nlpSolverIn__0, + nlpSolverIn__1, + nlpSolverIn__10, + nlpSolverIn__11, + nlpSolverIn__12, + nlpSolverIn__13, + nlpSolverIn__14, + nlpSolverIn__15, + nlpSolverIn__16, + nlpSolverIn__17, + nlpSolverIn__18, + nlpSolverIn__19, + nlpSolverIn__2, + nlpSolverIn__20, + nlpSolverIn__21, + nlpSolverIn__22, + nlpSolverIn__23, + nlpSolverIn__24, + nlpSolverIn__25, + nlpSolverIn__26, + nlpSolverIn__27, + nlpSolverIn__28, + nlpSolverIn__29, + nlpSolverIn__3, + nlpSolverIn__30, + nlpSolverIn__31, + nlpSolverIn__32, + nlpSolverIn__33, + nlpSolverIn__34, + nlpSolverIn__35, + nlpSolverIn__36, + nlpSolverIn__37, + nlpSolverIn__38, + nlpSolverIn__39, + nlpSolverIn__4, + nlpSolverIn__40, + nlpSolverIn__41, + nlpSolverIn__42, + nlpSolverIn__43, + nlpSolverIn__44, + nlpSolverIn__47, + nlpSolverIn__48, + nlpSolverIn__49, + nlpSolverIn__5, + nlpSolverIn__50, + nlpSolverIn__51, + nlpSolverIn__52, + nlpSolverIn__53, + nlpSolverIn__54, + nlpSolverIn__55, + nlpSolverIn__56, + nlpSolverIn__57, + nlpSolverIn__58, + nlpSolverIn__59, + nlpSolverIn__6, + nlpSolverIn__60, + nlpSolverIn__61, + nlpSolverIn__7, + nlpSolverIn__8, + nlpSolverIn__9, + nlpSolverOut__0, + nlpSolverOut__1, + nlpSolverOut__10, + nlpSolverOut__11, + nlpSolverOut__12, + nlpSolverOut__13, + nlpSolverOut__14, + nlpSolverOut__15, + nlpSolverOut__16, + nlpSolverOut__17, + nlpSolverOut__18, + nlpSolverOut__19, + nlpSolverOut__2, + nlpSolverOut__20, + nlpSolverOut__21, + nlpSolverOut__22, + nlpSolverOut__23, + nlpSolverOut__24, + nlpSolverOut__25, + nlpSolverOut__26, + nlpSolverOut__27, + nlpSolverOut__28, + nlpSolverOut__29, + nlpSolverOut__3, + nlpSolverOut__30, + nlpSolverOut__31, + nlpSolverOut__32, + nlpSolverOut__35, + nlpSolverOut__36, + nlpSolverOut__37, + nlpSolverOut__38, + nlpSolverOut__39, + nlpSolverOut__4, + nlpSolverOut__40, + nlpSolverOut__41, + nlpSolverOut__42, + nlpSolverOut__43, + nlpSolverOut__44, + nlpSolverOut__45, + nlpSolverOut__5, + nlpSolverOut__6, + nlpSolverOut__7, + nlpSolverOut__8, + nlpSolverOut__9, + qcqpIn__0, + qcqpIn__1, + qcqpIn__10, + qcqpIn__11, + qcqpIn__12, + qcqpIn__13, + qcqpIn__14, + qcqpIn__15, + qcqpIn__16, + qcqpIn__17, + qcqpIn__18, + qcqpIn__19, + qcqpIn__2, + qcqpIn__20, + qcqpIn__21, + qcqpIn__22, + qcqpIn__23, + qcqpIn__24, + qcqpIn__25, + qcqpIn__26, + qcqpIn__27, + qcqpIn__28, + qcqpIn__29, + qcqpIn__3, + qcqpIn__30, + qcqpIn__31, + qcqpIn__32, + qcqpIn__33, + qcqpIn__34, + qcqpIn__35, + qcqpIn__36, + qcqpIn__37, + qcqpIn__38, + qcqpIn__39, + qcqpIn__4, + qcqpIn__40, + qcqpIn__41, + qcqpIn__42, + qcqpIn__43, + qcqpIn__44, + qcqpIn__45, + qcqpIn__46, + qcqpIn__47, + qcqpIn__48, + qcqpIn__49, + qcqpIn__5, + qcqpIn__50, + qcqpIn__51, + qcqpIn__52, + qcqpIn__53, + qcqpIn__54, + qcqpIn__55, + qcqpIn__56, + qcqpIn__57, + qcqpIn__58, + qcqpIn__59, + qcqpIn__6, + qcqpIn__60, + qcqpIn__61, + qcqpIn__62, + qcqpIn__63, + qcqpIn__64, + qcqpIn__65, + qcqpIn__66, + qcqpIn__67, + qcqpIn__68, + qcqpIn__7, + qcqpIn__71, + qcqpIn__72, + qcqpIn__73, + qcqpIn__74, + qcqpIn__75, + qcqpIn__76, + qcqpIn__77, + qcqpIn__78, + qcqpIn__79, + qcqpIn__8, + qcqpIn__80, + qcqpIn__81, + qcqpIn__82, + qcqpIn__83, + qcqpIn__84, + qcqpIn__85, + qcqpIn__86, + qcqpIn__87, + qcqpIn__88, + qcqpIn__89, + qcqpIn__9, + qcqpIn__90, + qcqpIn__91, + qcqpIn__92, + qcqpIn__93, + qcqpOut__0, + qcqpOut__1, + qcqpOut__10, + qcqpOut__11, + qcqpOut__12, + qcqpOut__13, + qcqpOut__14, + qcqpOut__15, + qcqpOut__16, + qcqpOut__17, + qcqpOut__18, + qcqpOut__19, + qcqpOut__2, + qcqpOut__20, + qcqpOut__23, + qcqpOut__24, + qcqpOut__25, + qcqpOut__26, + qcqpOut__27, + qcqpOut__28, + qcqpOut__29, + qcqpOut__3, + qcqpOut__4, + qcqpOut__5, + qcqpOut__6, + qcqpOut__7, + qcqpOut__8, + qcqpOut__9, + qpIn__0, + qpIn__1, + qpIn__10, + qpIn__11, + qpIn__12, + qpIn__13, + qpIn__14, + qpIn__15, + qpIn__16, + qpIn__17, + qpIn__18, + qpIn__19, + qpIn__2, + qpIn__20, + qpIn__21, + qpIn__22, + qpIn__23, + qpIn__24, + qpIn__25, + qpIn__26, + qpIn__27, + qpIn__28, + qpIn__29, + qpIn__3, + qpIn__30, + qpIn__31, + qpIn__32, + qpIn__33, + qpIn__34, + qpIn__35, + qpIn__36, + qpIn__37, + qpIn__38, + qpIn__39, + qpIn__4, + qpIn__40, + qpIn__41, + qpIn__42, + qpIn__43, + qpIn__44, + qpIn__45, + qpIn__46, + qpIn__47, + qpIn__48, + qpIn__49, + qpIn__5, + qpIn__50, + qpIn__53, + qpIn__54, + qpIn__55, + qpIn__56, + qpIn__57, + qpIn__58, + qpIn__59, + qpIn__6, + qpIn__60, + qpIn__61, + qpIn__62, + qpIn__63, + qpIn__64, + qpIn__65, + qpIn__66, + qpIn__67, + qpIn__68, + qpIn__69, + qpIn__7, + qpIn__8, + qpIn__9, + qpOut__0, + qpOut__1, + qpOut__10, + qpOut__11, + qpOut__12, + qpOut__13, + qpOut__14, + qpOut__15, + qpOut__16, + qpOut__17, + qpOut__18, + qpOut__19, + qpOut__2, + qpOut__20, + qpOut__23, + qpOut__24, + qpOut__25, + qpOut__26, + qpOut__27, + qpOut__28, + qpOut__29, + qpOut__3, + qpOut__4, + qpOut__5, + qpOut__6, + qpOut__7, + qpOut__8, + qpOut__9, + rdaeIn__0, + rdaeIn__1, + rdaeIn__10, + rdaeIn__11, + rdaeIn__12, + rdaeIn__13, + rdaeIn__14, + rdaeIn__15, + rdaeIn__16, + rdaeIn__17, + rdaeIn__18, + rdaeIn__19, + rdaeIn__2, + rdaeIn__20, + rdaeIn__21, + rdaeIn__22, + rdaeIn__23, + rdaeIn__24, + rdaeIn__25, + rdaeIn__26, + rdaeIn__27, + rdaeIn__28, + rdaeIn__29, + rdaeIn__3, + rdaeIn__30, + rdaeIn__31, + rdaeIn__32, + rdaeIn__33, + rdaeIn__34, + rdaeIn__35, + rdaeIn__36, + rdaeIn__37, + rdaeIn__38, + rdaeIn__4, + rdaeIn__41, + rdaeIn__42, + rdaeIn__43, + rdaeIn__44, + rdaeIn__45, + rdaeIn__46, + rdaeIn__47, + rdaeIn__48, + rdaeIn__49, + rdaeIn__5, + rdaeIn__50, + rdaeIn__51, + rdaeIn__52, + rdaeIn__53, + rdaeIn__6, + rdaeIn__7, + rdaeIn__8, + rdaeIn__9, + rdaeOut__0, + rdaeOut__1, + rdaeOut__10, + rdaeOut__11, + rdaeOut__12, + rdaeOut__13, + rdaeOut__14, + rdaeOut__17, + rdaeOut__18, + rdaeOut__19, + rdaeOut__2, + rdaeOut__20, + rdaeOut__21, + rdaeOut__3, + rdaeOut__4, + rdaeOut__5, + rdaeOut__6, + rdaeOut__7, + rdaeOut__8, + rdaeOut__9, + sdpIn__0, + sdpIn__1, + sdpIn__10, + sdpIn__11, + sdpIn__12, + sdpIn__13, + sdpIn__14, + sdpIn__15, + sdpIn__16, + sdpIn__17, + sdpIn__18, + sdpIn__19, + sdpIn__2, + sdpIn__20, + sdpIn__21, + sdpIn__22, + sdpIn__23, + sdpIn__24, + sdpIn__25, + sdpIn__26, + sdpIn__27, + sdpIn__28, + sdpIn__29, + sdpIn__3, + sdpIn__30, + sdpIn__31, + sdpIn__32, + sdpIn__33, + sdpIn__34, + sdpIn__35, + sdpIn__36, + sdpIn__37, + sdpIn__38, + sdpIn__39, + sdpIn__4, + sdpIn__40, + sdpIn__41, + sdpIn__42, + sdpIn__43, + sdpIn__44, + sdpIn__47, + sdpIn__48, + sdpIn__49, + sdpIn__5, + sdpIn__50, + sdpIn__51, + sdpIn__52, + sdpIn__53, + sdpIn__54, + sdpIn__55, + sdpIn__56, + sdpIn__57, + sdpIn__58, + sdpIn__59, + sdpIn__6, + sdpIn__60, + sdpIn__61, + sdpIn__7, + sdpIn__8, + sdpIn__9, + sdpOut__0, + sdpOut__1, + sdpOut__10, + sdpOut__11, + sdpOut__12, + sdpOut__13, + sdpOut__14, + sdpOut__15, + sdpOut__16, + sdpOut__17, + sdpOut__18, + sdpOut__19, + sdpOut__2, + sdpOut__20, + sdpOut__21, + sdpOut__22, + sdpOut__23, + sdpOut__24, + sdpOut__25, + sdpOut__26, + sdpOut__27, + sdpOut__28, + sdpOut__29, + sdpOut__3, + sdpOut__30, + sdpOut__31, + sdpOut__32, + sdpOut__33, + sdpOut__34, + sdpOut__35, + sdpOut__36, + sdpOut__37, + sdpOut__38, + sdpOut__4, + sdpOut__41, + sdpOut__42, + sdpOut__43, + sdpOut__44, + sdpOut__45, + sdpOut__46, + sdpOut__47, + sdpOut__48, + sdpOut__49, + sdpOut__5, + sdpOut__50, + sdpOut__51, + sdpOut__52, + sdpOut__53, + sdpOut__6, + sdpOut__7, + sdpOut__8, + sdpOut__9, + sdqpIn__0, + sdqpIn__1, + sdqpIn__10, + sdqpIn__11, + sdqpIn__12, + sdqpIn__13, + sdqpIn__14, + sdqpIn__15, + sdqpIn__16, + sdqpIn__17, + sdqpIn__18, + sdqpIn__19, + sdqpIn__2, + sdqpIn__20, + sdqpIn__21, + sdqpIn__22, + sdqpIn__23, + sdqpIn__24, + sdqpIn__25, + sdqpIn__26, + sdqpIn__27, + sdqpIn__28, + sdqpIn__29, + sdqpIn__3, + sdqpIn__30, + sdqpIn__31, + sdqpIn__32, + sdqpIn__33, + sdqpIn__34, + sdqpIn__35, + sdqpIn__36, + sdqpIn__37, + sdqpIn__38, + sdqpIn__39, + sdqpIn__4, + sdqpIn__40, + sdqpIn__41, + sdqpIn__42, + sdqpIn__43, + sdqpIn__44, + sdqpIn__45, + sdqpIn__46, + sdqpIn__47, + sdqpIn__48, + sdqpIn__49, + sdqpIn__5, + sdqpIn__50, + sdqpIn__53, + sdqpIn__54, + sdqpIn__55, + sdqpIn__56, + sdqpIn__57, + sdqpIn__58, + sdqpIn__59, + sdqpIn__6, + sdqpIn__60, + sdqpIn__61, + sdqpIn__62, + sdqpIn__63, + sdqpIn__64, + sdqpIn__65, + sdqpIn__66, + sdqpIn__67, + sdqpIn__68, + sdqpIn__69, + sdqpIn__7, + sdqpIn__8, + sdqpIn__9, + sdqpOut__0, + sdqpOut__1, + sdqpOut__10, + sdqpOut__11, + sdqpOut__12, + sdqpOut__13, + sdqpOut__14, + sdqpOut__15, + sdqpOut__16, + sdqpOut__17, + sdqpOut__18, + sdqpOut__19, + sdqpOut__2, + sdqpOut__20, + sdqpOut__21, + sdqpOut__22, + sdqpOut__23, + sdqpOut__24, + sdqpOut__25, + sdqpOut__26, + sdqpOut__27, + sdqpOut__28, + sdqpOut__29, + sdqpOut__3, + sdqpOut__30, + sdqpOut__31, + sdqpOut__32, + sdqpOut__33, + sdqpOut__34, + sdqpOut__35, + sdqpOut__36, + sdqpOut__37, + sdqpOut__38, + sdqpOut__4, + sdqpOut__41, + sdqpOut__42, + sdqpOut__43, + sdqpOut__44, + sdqpOut__45, + sdqpOut__46, + sdqpOut__47, + sdqpOut__48, + sdqpOut__49, + sdqpOut__5, + sdqpOut__50, + sdqpOut__51, + sdqpOut__52, + sdqpOut__53, + sdqpOut__6, + sdqpOut__7, + sdqpOut__8, + sdqpOut__9, + simpleIRK__0, + simpleIRK__1, + simpleIRK__2, + simpleIRK__3, + simpleIRK__4, + simpleIRK__5, + simpleIntegrator__0, + simpleIntegrator__1, + simpleIntegrator__2, + simpleRK__0, + simpleRK__1, + simpleRK__2, + socpIn__0, + socpIn__1, + socpIn__10, + socpIn__11, + socpIn__12, + socpIn__13, + socpIn__14, + socpIn__15, + socpIn__16, + socpIn__17, + socpIn__18, + socpIn__19, + socpIn__2, + socpIn__20, + socpIn__21, + socpIn__22, + socpIn__23, + socpIn__24, + socpIn__25, + socpIn__26, + socpIn__27, + socpIn__28, + socpIn__29, + socpIn__3, + socpIn__30, + socpIn__31, + socpIn__32, + socpIn__33, + socpIn__34, + socpIn__35, + socpIn__36, + socpIn__37, + socpIn__38, + socpIn__39, + socpIn__4, + socpIn__40, + socpIn__41, + socpIn__42, + socpIn__43, + socpIn__44, + socpIn__45, + socpIn__46, + socpIn__47, + socpIn__48, + socpIn__49, + socpIn__5, + socpIn__50, + socpIn__51, + socpIn__52, + socpIn__53, + socpIn__54, + socpIn__55, + socpIn__56, + socpIn__59, + socpIn__6, + socpIn__60, + socpIn__61, + socpIn__62, + socpIn__63, + socpIn__64, + socpIn__65, + socpIn__66, + socpIn__67, + socpIn__68, + socpIn__69, + socpIn__7, + socpIn__70, + socpIn__71, + socpIn__72, + socpIn__73, + socpIn__74, + socpIn__75, + socpIn__76, + socpIn__77, + socpIn__8, + socpIn__9, + socpOut__0, + socpOut__1, + socpOut__10, + socpOut__11, + socpOut__12, + socpOut__13, + socpOut__14, + socpOut__15, + socpOut__16, + socpOut__17, + socpOut__18, + socpOut__19, + socpOut__2, + socpOut__20, + socpOut__21, + socpOut__22, + socpOut__23, + socpOut__24, + socpOut__25, + socpOut__26, + socpOut__27, + socpOut__28, + socpOut__29, + socpOut__3, + socpOut__30, + socpOut__31, + socpOut__32, + socpOut__35, + socpOut__36, + socpOut__37, + socpOut__38, + socpOut__39, + socpOut__4, + socpOut__40, + socpOut__41, + socpOut__42, + socpOut__43, + socpOut__44, + socpOut__45, + socpOut__5, + socpOut__6, + socpOut__7, + socpOut__8, + socpOut__9, + socpStruct__2, + socpStruct__3, + socpStruct__4, + socpStruct__5, + socpStruct__6, + stabilizedQpIn__0, + stabilizedQpIn__1, + stabilizedQpIn__10, + stabilizedQpIn__11, + stabilizedQpIn__12, + stabilizedQpIn__13, + stabilizedQpIn__14, + stabilizedQpIn__15, + stabilizedQpIn__16, + stabilizedQpIn__17, + stabilizedQpIn__18, + stabilizedQpIn__19, + stabilizedQpIn__2, + stabilizedQpIn__20, + stabilizedQpIn__21, + stabilizedQpIn__22, + stabilizedQpIn__23, + stabilizedQpIn__24, + stabilizedQpIn__25, + stabilizedQpIn__26, + stabilizedQpIn__27, + stabilizedQpIn__28, + stabilizedQpIn__29, + stabilizedQpIn__3, + stabilizedQpIn__30, + stabilizedQpIn__31, + stabilizedQpIn__32, + stabilizedQpIn__33, + stabilizedQpIn__34, + stabilizedQpIn__35, + stabilizedQpIn__36, + stabilizedQpIn__37, + stabilizedQpIn__38, + stabilizedQpIn__39, + stabilizedQpIn__4, + stabilizedQpIn__40, + stabilizedQpIn__41, + stabilizedQpIn__42, + stabilizedQpIn__43, + stabilizedQpIn__44, + stabilizedQpIn__45, + stabilizedQpIn__46, + stabilizedQpIn__47, + stabilizedQpIn__48, + stabilizedQpIn__49, + stabilizedQpIn__5, + stabilizedQpIn__50, + stabilizedQpIn__51, + stabilizedQpIn__52, + stabilizedQpIn__53, + stabilizedQpIn__54, + stabilizedQpIn__55, + stabilizedQpIn__56, + stabilizedQpIn__57, + stabilizedQpIn__58, + stabilizedQpIn__59, + stabilizedQpIn__6, + stabilizedQpIn__60, + stabilizedQpIn__61, + stabilizedQpIn__62, + stabilizedQpIn__63, + stabilizedQpIn__64, + stabilizedQpIn__65, + stabilizedQpIn__66, + stabilizedQpIn__67, + stabilizedQpIn__68, + stabilizedQpIn__7, + stabilizedQpIn__71, + stabilizedQpIn__72, + stabilizedQpIn__73, + stabilizedQpIn__74, + stabilizedQpIn__75, + stabilizedQpIn__76, + stabilizedQpIn__77, + stabilizedQpIn__78, + stabilizedQpIn__79, + stabilizedQpIn__8, + stabilizedQpIn__80, + stabilizedQpIn__81, + stabilizedQpIn__82, + stabilizedQpIn__83, + stabilizedQpIn__84, + stabilizedQpIn__85, + stabilizedQpIn__86, + stabilizedQpIn__87, + stabilizedQpIn__88, + stabilizedQpIn__89, + stabilizedQpIn__9, + stabilizedQpIn__90, + stabilizedQpIn__91, + stabilizedQpIn__92, + stabilizedQpIn__93, + ) where + + +import Data.Vector ( Vector ) +import qualified Data.Map as M +import Foreign.C.Types +import Foreign.Marshal ( new, free ) +import Foreign.Storable ( peek ) +import Foreign.Ptr ( Ptr, nullPtr ) + +import Casadi.Core.Data +import Casadi.Core.Enums +import Casadi.Internal.FormatException ( formatException ) +import Casadi.Internal.MarshalTypes ( StdMap, StdVec, StdString, StdPair ) +import Casadi.Internal.Marshal ( withMarshal ) +import Casadi.Internal.WrapReturn ( WrapReturn(..) ) +foreign import ccall unsafe "IOScheme__0" c_IOScheme__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__0 + :: String -> IO (Vector String) +iOScheme__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__1" c_IOScheme__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__1 + :: String -> String -> IO (Vector String) +iOScheme__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__2" c_IOScheme__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__2 + :: String -> String -> String -> IO (Vector String) +iOScheme__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__3" c_IOScheme__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__3 + :: String -> String -> String -> String -> IO (Vector String) +iOScheme__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__4" c_IOScheme__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__4 + :: String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__4 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__4 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__5" c_IOScheme__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__5 + :: String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__5 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__5 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__6" c_IOScheme__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__6 + :: String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__6 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__7" c_IOScheme__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__7 + :: String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__7 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__8" c_IOScheme__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__8 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__9" c_IOScheme__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__9 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__10" c_IOScheme__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__10 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__11" c_IOScheme__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__11 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__12" c_IOScheme__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__12 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__13" c_IOScheme__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__13 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__14" c_IOScheme__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__14 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__15" c_IOScheme__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__15 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__16" c_IOScheme__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__16 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__17" c_IOScheme__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__17 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__18" c_IOScheme__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__18 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__19" c_IOScheme__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__19 + :: String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector String) +iOScheme__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__20" c_IOScheme__20 + :: Ptr (Ptr StdString) -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__20 + :: IO (Vector String) +iOScheme__20 = + + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__20 errStrPtrP + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__21" c_IOScheme__21 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__21 + :: Vector String -> IO (Vector String) +iOScheme__21 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__21 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__22" c_IOScheme__22 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr StdString)) -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__22 + :: Vector String -> Vector String -> IO (Vector String) +iOScheme__22 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__22 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "IOScheme__23" c_IOScheme__23 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec (Ptr StdString))) +iOScheme__23 + :: InputOutputScheme -> IO (Vector String) +iOScheme__23 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_IOScheme__23 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_abs__0" c_casadi_abs__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_abs__0 + :: SX -> IO SX +casadi_abs__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_abs__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_abs__1" c_casadi_abs__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_abs__1 + :: DMatrix -> IO DMatrix +casadi_abs__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_abs__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_abs__2" c_casadi_abs__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_abs__2 + :: IMatrix -> IO IMatrix +casadi_abs__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_abs__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_abs__3" c_casadi_abs__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_abs__3 + :: MX -> IO MX +casadi_abs__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_abs__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acos__0" c_casadi_acos__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_acos__0 + :: SX -> IO SX +casadi_acos__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acos__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acos__1" c_casadi_acos__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_acos__1 + :: DMatrix -> IO DMatrix +casadi_acos__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acos__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acos__2" c_casadi_acos__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_acos__2 + :: IMatrix -> IO IMatrix +casadi_acos__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acos__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acos__3" c_casadi_acos__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_acos__3 + :: MX -> IO MX +casadi_acos__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acos__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acosh__0" c_casadi_acosh__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_acosh__0 + :: SX -> IO SX +casadi_acosh__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acosh__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acosh__1" c_casadi_acosh__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_acosh__1 + :: DMatrix -> IO DMatrix +casadi_acosh__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acosh__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acosh__2" c_casadi_acosh__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_acosh__2 + :: IMatrix -> IO IMatrix +casadi_acosh__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acosh__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_acosh__3" c_casadi_acosh__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_acosh__3 + :: MX -> IO MX +casadi_acosh__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_acosh__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_adj__0" c_casadi_adj__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_adj__0 + :: SX -> IO SX +casadi_adj__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_adj__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_adj__1" c_casadi_adj__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_adj__1 + :: DMatrix -> IO DMatrix +casadi_adj__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_adj__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_adj__2" c_casadi_adj__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_adj__2 + :: IMatrix -> IO IMatrix +casadi_adj__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_adj__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_all__0" c_casadi_all__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_all__0 + :: SX -> IO SX +casadi_all__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_all__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_all__1" c_casadi_all__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_all__1 + :: DMatrix -> IO DMatrix +casadi_all__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_all__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_all__2" c_casadi_all__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_all__2 + :: IMatrix -> IO IMatrix +casadi_all__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_all__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_and__0" c_casadi_and__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_and__0 + :: SX -> SX -> IO SX +casadi_and__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_and__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_and__1" c_casadi_and__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_and__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_and__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_and__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_and__2" c_casadi_and__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_and__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_and__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_and__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_and__3" c_casadi_and__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_and__3 + :: MX -> MX -> IO MX +casadi_and__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_and__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_any__0" c_casadi_any__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_any__0 + :: SX -> IO SX +casadi_any__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_any__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_any__1" c_casadi_any__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_any__1 + :: DMatrix -> IO DMatrix +casadi_any__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_any__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_any__2" c_casadi_any__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_any__2 + :: IMatrix -> IO IMatrix +casadi_any__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_any__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asin__0" c_casadi_asin__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_asin__0 + :: SX -> IO SX +casadi_asin__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asin__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asin__1" c_casadi_asin__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_asin__1 + :: DMatrix -> IO DMatrix +casadi_asin__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asin__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asin__2" c_casadi_asin__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_asin__2 + :: IMatrix -> IO IMatrix +casadi_asin__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asin__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asin__3" c_casadi_asin__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_asin__3 + :: MX -> IO MX +casadi_asin__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asin__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asinh__0" c_casadi_asinh__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_asinh__0 + :: SX -> IO SX +casadi_asinh__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asinh__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asinh__1" c_casadi_asinh__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_asinh__1 + :: DMatrix -> IO DMatrix +casadi_asinh__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asinh__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asinh__2" c_casadi_asinh__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_asinh__2 + :: IMatrix -> IO IMatrix +casadi_asinh__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asinh__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_asinh__3" c_casadi_asinh__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_asinh__3 + :: MX -> IO MX +casadi_asinh__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_asinh__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan__0" c_casadi_atan__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_atan__0 + :: SX -> IO SX +casadi_atan__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan__1" c_casadi_atan__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_atan__1 + :: DMatrix -> IO DMatrix +casadi_atan__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan__2" c_casadi_atan__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_atan__2 + :: IMatrix -> IO IMatrix +casadi_atan__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan__3" c_casadi_atan__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_atan__3 + :: MX -> IO MX +casadi_atan__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan2__0" c_casadi_atan2__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_atan2__0 + :: SX -> SX -> IO SX +casadi_atan2__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan2__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan2__1" c_casadi_atan2__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_atan2__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_atan2__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan2__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan2__2" c_casadi_atan2__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_atan2__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_atan2__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan2__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atan2__3" c_casadi_atan2__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_atan2__3 + :: MX -> MX -> IO MX +casadi_atan2__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atan2__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atanh__0" c_casadi_atanh__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_atanh__0 + :: SX -> IO SX +casadi_atanh__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atanh__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atanh__1" c_casadi_atanh__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_atanh__1 + :: DMatrix -> IO DMatrix +casadi_atanh__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atanh__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atanh__2" c_casadi_atanh__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_atanh__2 + :: IMatrix -> IO IMatrix +casadi_atanh__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atanh__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_atanh__3" c_casadi_atanh__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_atanh__3 + :: MX -> IO MX +casadi_atanh__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_atanh__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__0" c_casadi_blockcat__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_blockcat__0 + :: SX -> SX -> SX -> SX -> IO SX +casadi_blockcat__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__1" c_casadi_blockcat__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO (Ptr SX') +casadi_blockcat__1 + :: Vector (Vector SX) -> IO SX +casadi_blockcat__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__2" c_casadi_blockcat__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_blockcat__2 + :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_blockcat__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__3" c_casadi_blockcat__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO (Ptr DMatrix') +casadi_blockcat__3 + :: Vector (Vector DMatrix) -> IO DMatrix +casadi_blockcat__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__4" c_casadi_blockcat__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_blockcat__4 + :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_blockcat__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__5" c_casadi_blockcat__5 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))) -> IO (Ptr IMatrix') +casadi_blockcat__5 + :: Vector (Vector IMatrix) -> IO IMatrix +casadi_blockcat__5 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__5 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__6" c_casadi_blockcat__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_blockcat__6 + :: MX -> MX -> MX -> MX -> IO MX +casadi_blockcat__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__7" c_casadi_blockcat__7 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr MX') +casadi_blockcat__7 + :: Vector (Vector MX) -> IO MX +casadi_blockcat__7 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__7 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__8" c_casadi_blockcat__8 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_blockcat__8 + :: Sparsity -> Sparsity -> Sparsity -> Sparsity -> IO Sparsity +casadi_blockcat__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blockcat__9" c_casadi_blockcat__9 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr Sparsity') +casadi_blockcat__9 + :: Vector (Vector Sparsity) -> IO Sparsity +casadi_blockcat__9 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blockcat__9 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__0" c_casadi_blocksplit__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) +casadi_blocksplit__0 + :: SX -> IO (Vector (Vector SX)) +casadi_blocksplit__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__1" c_casadi_blocksplit__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) +casadi_blocksplit__1 + :: SX -> Int -> IO (Vector (Vector SX)) +casadi_blocksplit__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__2" c_casadi_blocksplit__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) +casadi_blocksplit__2 + :: SX -> Int -> Int -> IO (Vector (Vector SX)) +casadi_blocksplit__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__3" c_casadi_blocksplit__3 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX'))))) +casadi_blocksplit__3 + :: SX -> Vector Int -> Vector Int -> IO (Vector (Vector SX)) +casadi_blocksplit__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__4" c_casadi_blocksplit__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) +casadi_blocksplit__4 + :: DMatrix -> IO (Vector (Vector DMatrix)) +casadi_blocksplit__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__5" c_casadi_blocksplit__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) +casadi_blocksplit__5 + :: DMatrix -> Int -> IO (Vector (Vector DMatrix)) +casadi_blocksplit__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__6" c_casadi_blocksplit__6 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) +casadi_blocksplit__6 + :: DMatrix -> Int -> Int -> IO (Vector (Vector DMatrix)) +casadi_blocksplit__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__7" c_casadi_blocksplit__7 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix'))))) +casadi_blocksplit__7 + :: DMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix)) +casadi_blocksplit__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__8" c_casadi_blocksplit__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) +casadi_blocksplit__8 + :: IMatrix -> IO (Vector (Vector IMatrix)) +casadi_blocksplit__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__9" c_casadi_blocksplit__9 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) +casadi_blocksplit__9 + :: IMatrix -> Int -> IO (Vector (Vector IMatrix)) +casadi_blocksplit__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__10" c_casadi_blocksplit__10 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) +casadi_blocksplit__10 + :: IMatrix -> Int -> Int -> IO (Vector (Vector IMatrix)) +casadi_blocksplit__10 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__10 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__11" c_casadi_blocksplit__11 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix'))))) +casadi_blocksplit__11 + :: IMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix)) +casadi_blocksplit__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__12" c_casadi_blocksplit__12 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi_blocksplit__12 + :: MX -> IO (Vector (Vector MX)) +casadi_blocksplit__12 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__12 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__13" c_casadi_blocksplit__13 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi_blocksplit__13 + :: MX -> Int -> IO (Vector (Vector MX)) +casadi_blocksplit__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__14" c_casadi_blocksplit__14 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi_blocksplit__14 + :: MX -> Int -> Int -> IO (Vector (Vector MX)) +casadi_blocksplit__14 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__14 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__15" c_casadi_blocksplit__15 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX'))))) +casadi_blocksplit__15 + :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX)) +casadi_blocksplit__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__16" c_casadi_blocksplit__16 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) +casadi_blocksplit__16 + :: Sparsity -> IO (Vector (Vector Sparsity)) +casadi_blocksplit__16 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__16 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__17" c_casadi_blocksplit__17 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) +casadi_blocksplit__17 + :: Sparsity -> Int -> IO (Vector (Vector Sparsity)) +casadi_blocksplit__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__18" c_casadi_blocksplit__18 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) +casadi_blocksplit__18 + :: Sparsity -> Int -> Int -> IO (Vector (Vector Sparsity)) +casadi_blocksplit__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_blocksplit__19" c_casadi_blocksplit__19 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr Sparsity'))))) +casadi_blocksplit__19 + :: Sparsity -> Vector Int -> Vector Int -> IO (Vector (Vector Sparsity)) +casadi_blocksplit__19 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_blocksplit__19 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ceil__0" c_casadi_ceil__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_ceil__0 + :: SX -> IO SX +casadi_ceil__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ceil__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ceil__1" c_casadi_ceil__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_ceil__1 + :: DMatrix -> IO DMatrix +casadi_ceil__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ceil__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ceil__2" c_casadi_ceil__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_ceil__2 + :: IMatrix -> IO IMatrix +casadi_ceil__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ceil__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ceil__3" c_casadi_ceil__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_ceil__3 + :: MX -> IO MX +casadi_ceil__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ceil__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_chol__0" c_casadi_chol__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_chol__0 + :: SX -> IO SX +casadi_chol__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_chol__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_chol__1" c_casadi_chol__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_chol__1 + :: DMatrix -> IO DMatrix +casadi_chol__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_chol__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_chol__2" c_casadi_chol__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_chol__2 + :: IMatrix -> IO IMatrix +casadi_chol__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_chol__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cofactor__0" c_casadi_cofactor__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') +casadi_cofactor__0 + :: SX -> Int -> Int -> IO SX +casadi_cofactor__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cofactor__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cofactor__1" c_casadi_cofactor__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') +casadi_cofactor__1 + :: DMatrix -> Int -> Int -> IO DMatrix +casadi_cofactor__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cofactor__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cofactor__2" c_casadi_cofactor__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') +casadi_cofactor__2 + :: IMatrix -> Int -> Int -> IO IMatrix +casadi_cofactor__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cofactor__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__0" c_casadi_conditional__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> Ptr SX' -> IO (Ptr SX') +casadi_conditional__0 + :: SX -> Vector SX -> SX -> IO SX +casadi_conditional__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__1" c_casadi_conditional__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_conditional__1 + :: SX -> Vector SX -> SX -> Bool -> IO SX +casadi_conditional__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__2" c_casadi_conditional__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_conditional__2 + :: DMatrix -> Vector DMatrix -> DMatrix -> IO DMatrix +casadi_conditional__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__3" c_casadi_conditional__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr DMatrix')) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_conditional__3 + :: DMatrix -> Vector DMatrix -> DMatrix -> Bool -> IO DMatrix +casadi_conditional__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__4" c_casadi_conditional__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr IMatrix')) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_conditional__4 + :: IMatrix -> Vector IMatrix -> IMatrix -> IO IMatrix +casadi_conditional__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__5" c_casadi_conditional__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr IMatrix')) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_conditional__5 + :: IMatrix -> Vector IMatrix -> IMatrix -> Bool -> IO IMatrix +casadi_conditional__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__6" c_casadi_conditional__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr MX' -> IO (Ptr MX') +casadi_conditional__6 + :: MX -> Vector MX -> MX -> IO MX +casadi_conditional__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_conditional__7" c_casadi_conditional__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_conditional__7 + :: MX -> Vector MX -> MX -> Bool -> IO MX +casadi_conditional__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_conditional__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_constpow__0" c_casadi_constpow__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_constpow__0 + :: SX -> SX -> IO SX +casadi_constpow__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_constpow__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_constpow__1" c_casadi_constpow__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_constpow__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_constpow__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_constpow__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_constpow__2" c_casadi_constpow__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_constpow__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_constpow__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_constpow__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_constpow__3" c_casadi_constpow__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_constpow__3 + :: MX -> MX -> IO MX +casadi_constpow__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_constpow__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_copysign__0" c_casadi_copysign__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_copysign__0 + :: SX -> SX -> IO SX +casadi_copysign__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_copysign__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_copysign__1" c_casadi_copysign__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_copysign__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_copysign__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_copysign__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_copysign__2" c_casadi_copysign__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_copysign__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_copysign__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_copysign__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_copysign__3" c_casadi_copysign__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_copysign__3 + :: MX -> MX -> IO MX +casadi_copysign__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_copysign__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cos__0" c_casadi_cos__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_cos__0 + :: SX -> IO SX +casadi_cos__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cos__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cos__1" c_casadi_cos__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_cos__1 + :: DMatrix -> IO DMatrix +casadi_cos__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cos__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cos__2" c_casadi_cos__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_cos__2 + :: IMatrix -> IO IMatrix +casadi_cos__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cos__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cos__3" c_casadi_cos__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_cos__3 + :: MX -> IO MX +casadi_cos__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cos__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cosh__0" c_casadi_cosh__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_cosh__0 + :: SX -> IO SX +casadi_cosh__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cosh__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cosh__1" c_casadi_cosh__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_cosh__1 + :: DMatrix -> IO DMatrix +casadi_cosh__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cosh__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cosh__2" c_casadi_cosh__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_cosh__2 + :: IMatrix -> IO IMatrix +casadi_cosh__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cosh__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cosh__3" c_casadi_cosh__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_cosh__3 + :: MX -> IO MX +casadi_cosh__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cosh__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_countNodes__0" c_casadi_countNodes__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi_countNodes__0 + :: SX -> IO Int +casadi_countNodes__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_countNodes__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_countNodes__1" c_casadi_countNodes__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi_countNodes__1 + :: DMatrix -> IO Int +casadi_countNodes__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_countNodes__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_countNodes__2" c_casadi_countNodes__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi_countNodes__2 + :: IMatrix -> IO Int +casadi_countNodes__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_countNodes__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_countNodes__3" c_casadi_countNodes__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi_countNodes__3 + :: MX -> IO Int +casadi_countNodes__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_countNodes__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__0" c_casadi_cross__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_cross__0 + :: SX -> SX -> IO SX +casadi_cross__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__1" c_casadi_cross__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_cross__1 + :: SX -> SX -> Int -> IO SX +casadi_cross__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__2" c_casadi_cross__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_cross__2 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_cross__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__3" c_casadi_cross__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_cross__3 + :: DMatrix -> DMatrix -> Int -> IO DMatrix +casadi_cross__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__4" c_casadi_cross__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_cross__4 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_cross__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__5" c_casadi_cross__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_cross__5 + :: IMatrix -> IMatrix -> Int -> IO IMatrix +casadi_cross__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__6" c_casadi_cross__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_cross__6 + :: MX -> MX -> IO MX +casadi_cross__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_cross__7" c_casadi_cross__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_cross__7 + :: MX -> MX -> Int -> IO MX +casadi_cross__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_cross__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_densify__0" c_casadi_densify__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_densify__0 + :: SX -> IO SX +casadi_densify__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_densify__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_densify__1" c_casadi_densify__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_densify__1 + :: DMatrix -> IO DMatrix +casadi_densify__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_densify__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_densify__2" c_casadi_densify__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_densify__2 + :: IMatrix -> IO IMatrix +casadi_densify__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_densify__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_densify__3" c_casadi_densify__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_densify__3 + :: MX -> IO MX +casadi_densify__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_densify__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_dependsOn__0" c_casadi_dependsOn__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt +casadi_dependsOn__0 + :: SX -> SX -> IO Bool +casadi_dependsOn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_dependsOn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_dependsOn__1" c_casadi_dependsOn__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt +casadi_dependsOn__1 + :: DMatrix -> DMatrix -> IO Bool +casadi_dependsOn__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_dependsOn__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_dependsOn__2" c_casadi_dependsOn__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt +casadi_dependsOn__2 + :: IMatrix -> IMatrix -> IO Bool +casadi_dependsOn__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_dependsOn__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_dependsOn__3" c_casadi_dependsOn__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt +casadi_dependsOn__3 + :: MX -> MX -> IO Bool +casadi_dependsOn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_dependsOn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_det__0" c_casadi_det__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_det__0 + :: SX -> IO SX +casadi_det__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_det__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_det__1" c_casadi_det__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_det__1 + :: DMatrix -> IO DMatrix +casadi_det__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_det__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_det__2" c_casadi_det__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_det__2 + :: IMatrix -> IO IMatrix +casadi_det__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_det__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_det__3" c_casadi_det__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_det__3 + :: MX -> IO MX +casadi_det__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_det__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diag__0" c_casadi_diag__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_diag__0 + :: SX -> IO SX +casadi_diag__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diag__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diag__1" c_casadi_diag__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_diag__1 + :: DMatrix -> IO DMatrix +casadi_diag__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diag__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diag__2" c_casadi_diag__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_diag__2 + :: IMatrix -> IO IMatrix +casadi_diag__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diag__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diag__3" c_casadi_diag__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_diag__3 + :: MX -> IO MX +casadi_diag__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diag__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagcat__0" c_casadi_diagcat__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') +casadi_diagcat__0 + :: Vector SX -> IO SX +casadi_diagcat__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagcat__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagcat__1" c_casadi_diagcat__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') +casadi_diagcat__1 + :: Vector DMatrix -> IO DMatrix +casadi_diagcat__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagcat__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagcat__2" c_casadi_diagcat__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') +casadi_diagcat__2 + :: Vector IMatrix -> IO IMatrix +casadi_diagcat__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagcat__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagcat__3" c_casadi_diagcat__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi_diagcat__3 + :: Vector MX -> IO MX +casadi_diagcat__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagcat__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagcat__4" c_casadi_diagcat__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') +casadi_diagcat__4 + :: Vector Sparsity -> IO Sparsity +casadi_diagcat__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagcat__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__0" c_casadi_diagsplit__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi_diagsplit__0 + :: SX -> Int -> Int -> IO (Vector SX) +casadi_diagsplit__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__1" c_casadi_diagsplit__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX'))) +casadi_diagsplit__1 + :: SX -> IO (Vector SX) +casadi_diagsplit__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__2" c_casadi_diagsplit__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi_diagsplit__2 + :: SX -> Int -> IO (Vector SX) +casadi_diagsplit__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__3" c_casadi_diagsplit__3 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX'))) +casadi_diagsplit__3 + :: SX -> Vector Int -> IO (Vector SX) +casadi_diagsplit__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__4" c_casadi_diagsplit__4 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX'))) +casadi_diagsplit__4 + :: SX -> Vector Int -> Vector Int -> IO (Vector SX) +casadi_diagsplit__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__5" c_casadi_diagsplit__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_diagsplit__5 + :: DMatrix -> Int -> Int -> IO (Vector DMatrix) +casadi_diagsplit__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__6" c_casadi_diagsplit__6 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_diagsplit__6 + :: DMatrix -> IO (Vector DMatrix) +casadi_diagsplit__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__7" c_casadi_diagsplit__7 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_diagsplit__7 + :: DMatrix -> Int -> IO (Vector DMatrix) +casadi_diagsplit__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__8" c_casadi_diagsplit__8 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_diagsplit__8 + :: DMatrix -> Vector Int -> IO (Vector DMatrix) +casadi_diagsplit__8 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__8 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__9" c_casadi_diagsplit__9 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_diagsplit__9 + :: DMatrix -> Vector Int -> Vector Int -> IO (Vector DMatrix) +casadi_diagsplit__9 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__9 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__10" c_casadi_diagsplit__10 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_diagsplit__10 + :: IMatrix -> Int -> Int -> IO (Vector IMatrix) +casadi_diagsplit__10 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__10 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__11" c_casadi_diagsplit__11 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_diagsplit__11 + :: IMatrix -> IO (Vector IMatrix) +casadi_diagsplit__11 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__11 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__12" c_casadi_diagsplit__12 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_diagsplit__12 + :: IMatrix -> Int -> IO (Vector IMatrix) +casadi_diagsplit__12 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__12 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__13" c_casadi_diagsplit__13 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_diagsplit__13 + :: IMatrix -> Vector Int -> IO (Vector IMatrix) +casadi_diagsplit__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__14" c_casadi_diagsplit__14 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_diagsplit__14 + :: IMatrix -> Vector Int -> Vector Int -> IO (Vector IMatrix) +casadi_diagsplit__14 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__14 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__15" c_casadi_diagsplit__15 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi_diagsplit__15 + :: MX -> Int -> Int -> IO (Vector MX) +casadi_diagsplit__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__16" c_casadi_diagsplit__16 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) +casadi_diagsplit__16 + :: MX -> IO (Vector MX) +casadi_diagsplit__16 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__16 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__17" c_casadi_diagsplit__17 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi_diagsplit__17 + :: MX -> Int -> IO (Vector MX) +casadi_diagsplit__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__18" c_casadi_diagsplit__18 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_diagsplit__18 + :: MX -> Vector Int -> IO (Vector MX) +casadi_diagsplit__18 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__18 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__19" c_casadi_diagsplit__19 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_diagsplit__19 + :: MX -> Vector Int -> Vector Int -> IO (Vector MX) +casadi_diagsplit__19 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__19 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__20" c_casadi_diagsplit__20 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_diagsplit__20 + :: Sparsity -> Int -> Int -> IO (Vector Sparsity) +casadi_diagsplit__20 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__20 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__21" c_casadi_diagsplit__21 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_diagsplit__21 + :: Sparsity -> IO (Vector Sparsity) +casadi_diagsplit__21 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__21 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__22" c_casadi_diagsplit__22 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_diagsplit__22 + :: Sparsity -> Int -> IO (Vector Sparsity) +casadi_diagsplit__22 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__22 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__23" c_casadi_diagsplit__23 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_diagsplit__23 + :: Sparsity -> Vector Int -> IO (Vector Sparsity) +casadi_diagsplit__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_diagsplit__24" c_casadi_diagsplit__24 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_diagsplit__24 + :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Sparsity) +casadi_diagsplit__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_diagsplit__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_eig_symbolic__0" c_casadi_eig_symbolic__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_eig_symbolic__0 + :: SX -> IO SX +casadi_eig_symbolic__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_eig_symbolic__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_eig_symbolic__1" c_casadi_eig_symbolic__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_eig_symbolic__1 + :: DMatrix -> IO DMatrix +casadi_eig_symbolic__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_eig_symbolic__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_eig_symbolic__2" c_casadi_eig_symbolic__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_eig_symbolic__2 + :: IMatrix -> IO IMatrix +casadi_eig_symbolic__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_eig_symbolic__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_eq__0" c_casadi_eq__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_eq__0 + :: SX -> SX -> IO SX +casadi_eq__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_eq__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_eq__1" c_casadi_eq__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_eq__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_eq__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_eq__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_eq__2" c_casadi_eq__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_eq__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_eq__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_eq__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_eq__3" c_casadi_eq__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_eq__3 + :: MX -> MX -> IO MX +casadi_eq__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_eq__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erf__0" c_casadi_erf__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_erf__0 + :: SX -> IO SX +casadi_erf__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erf__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erf__1" c_casadi_erf__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_erf__1 + :: DMatrix -> IO DMatrix +casadi_erf__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erf__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erf__2" c_casadi_erf__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_erf__2 + :: IMatrix -> IO IMatrix +casadi_erf__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erf__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erf__3" c_casadi_erf__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_erf__3 + :: MX -> IO MX +casadi_erf__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erf__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erfinv__0" c_casadi_erfinv__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_erfinv__0 + :: SX -> IO SX +casadi_erfinv__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erfinv__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erfinv__1" c_casadi_erfinv__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_erfinv__1 + :: DMatrix -> IO DMatrix +casadi_erfinv__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erfinv__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erfinv__2" c_casadi_erfinv__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_erfinv__2 + :: IMatrix -> IO IMatrix +casadi_erfinv__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erfinv__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_erfinv__3" c_casadi_erfinv__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_erfinv__3 + :: MX -> IO MX +casadi_erfinv__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_erfinv__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_exp__0" c_casadi_exp__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_exp__0 + :: SX -> IO SX +casadi_exp__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_exp__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_exp__1" c_casadi_exp__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_exp__1 + :: DMatrix -> IO DMatrix +casadi_exp__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_exp__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_exp__2" c_casadi_exp__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_exp__2 + :: IMatrix -> IO IMatrix +casadi_exp__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_exp__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_exp__3" c_casadi_exp__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_exp__3 + :: MX -> IO MX +casadi_exp__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_exp__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_expand__0" c_casadi_expand__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () +casadi_expand__0 + :: SX -> SX -> SX -> IO () +casadi_expand__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_expand__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_expand__1" c_casadi_expand__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () +casadi_expand__1 + :: DMatrix -> DMatrix -> DMatrix -> IO () +casadi_expand__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_expand__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_expand__2" c_casadi_expand__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi_expand__2 + :: IMatrix -> IMatrix -> IMatrix -> IO () +casadi_expand__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_expand__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__0" c_casadi_extractShared__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () +casadi_extractShared__0 + :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> IO () +casadi_extractShared__0 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__0 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__1" c_casadi_extractShared__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO () +casadi_extractShared__1 + :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> String -> IO () +casadi_extractShared__1 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__1 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__2" c_casadi_extractShared__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO () +casadi_extractShared__2 + :: Vector SX -> Vector SX -> Vector SX -> Vector SX -> String -> String -> IO () +casadi_extractShared__2 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__2 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__3" c_casadi_extractShared__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO () +casadi_extractShared__3 + :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO () +casadi_extractShared__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__4" c_casadi_extractShared__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> IO () +casadi_extractShared__4 + :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> IO () +casadi_extractShared__4 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__4 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__5" c_casadi_extractShared__5 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> IO () +casadi_extractShared__5 + :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> String -> String -> IO () +casadi_extractShared__5 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__5 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__6" c_casadi_extractShared__6 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO () +casadi_extractShared__6 + :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () +casadi_extractShared__6 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__6 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__7" c_casadi_extractShared__7 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> IO () +casadi_extractShared__7 + :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> IO () +casadi_extractShared__7 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__7 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__8" c_casadi_extractShared__8 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr StdString -> Ptr StdString -> IO () +casadi_extractShared__8 + :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> String -> String -> IO () +casadi_extractShared__8 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__8 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__9" c_casadi_extractShared__9 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () +casadi_extractShared__9 + :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> IO () +casadi_extractShared__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__10" c_casadi_extractShared__10 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO () +casadi_extractShared__10 + :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> String -> IO () +casadi_extractShared__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_extractShared__11" c_casadi_extractShared__11 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO () +casadi_extractShared__11 + :: Vector MX -> Vector MX -> Vector MX -> Vector MX -> String -> String -> IO () +casadi_extractShared__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_extractShared__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_find" c_casadi_find + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_find + :: MX -> IO MX +casadi_find x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_find errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_floor__0" c_casadi_floor__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_floor__0 + :: SX -> IO SX +casadi_floor__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_floor__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_floor__1" c_casadi_floor__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_floor__1 + :: DMatrix -> IO DMatrix +casadi_floor__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_floor__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_floor__2" c_casadi_floor__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_floor__2 + :: IMatrix -> IO IMatrix +casadi_floor__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_floor__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_floor__3" c_casadi_floor__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_floor__3 + :: MX -> IO MX +casadi_floor__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_floor__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__0" c_casadi_gauss_quadrature__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr SX' -> IO (Ptr SX') +casadi_gauss_quadrature__0 + :: SX -> SX -> SX -> SX -> Int -> SX -> IO SX +casadi_gauss_quadrature__0 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__0 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__1" c_casadi_gauss_quadrature__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_gauss_quadrature__1 + :: SX -> SX -> SX -> SX -> IO SX +casadi_gauss_quadrature__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__2" c_casadi_gauss_quadrature__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_gauss_quadrature__2 + :: SX -> SX -> SX -> SX -> Int -> IO SX +casadi_gauss_quadrature__2 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__2 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__3" c_casadi_gauss_quadrature__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_gauss_quadrature__3 + :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> Int -> DMatrix -> IO DMatrix +casadi_gauss_quadrature__3 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__3 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__4" c_casadi_gauss_quadrature__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_gauss_quadrature__4 + :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_gauss_quadrature__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__5" c_casadi_gauss_quadrature__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_gauss_quadrature__5 + :: DMatrix -> DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix +casadi_gauss_quadrature__5 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__5 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__6" c_casadi_gauss_quadrature__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_gauss_quadrature__6 + :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IMatrix -> IO IMatrix +casadi_gauss_quadrature__6 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__6 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__7" c_casadi_gauss_quadrature__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_gauss_quadrature__7 + :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_gauss_quadrature__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gauss_quadrature__8" c_casadi_gauss_quadrature__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_gauss_quadrature__8 + :: IMatrix -> IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix +casadi_gauss_quadrature__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gauss_quadrature__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ge__0" c_casadi_ge__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_ge__0 + :: SX -> SX -> IO SX +casadi_ge__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ge__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ge__1" c_casadi_ge__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_ge__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_ge__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ge__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ge__2" c_casadi_ge__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_ge__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_ge__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ge__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ge__3" c_casadi_ge__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_ge__3 + :: MX -> MX -> IO MX +casadi_ge__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ge__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_getMinor__0" c_casadi_getMinor__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') +casadi_getMinor__0 + :: SX -> Int -> Int -> IO SX +casadi_getMinor__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_getMinor__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_getMinor__1" c_casadi_getMinor__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') +casadi_getMinor__1 + :: DMatrix -> Int -> Int -> IO DMatrix +casadi_getMinor__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_getMinor__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_getMinor__2" c_casadi_getMinor__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') +casadi_getMinor__2 + :: IMatrix -> Int -> Int -> IO IMatrix +casadi_getMinor__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_getMinor__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_getOperatorRepresentation__0" c_casadi_getOperatorRepresentation__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) +casadi_getOperatorRepresentation__0 + :: SX -> Vector String -> IO String +casadi_getOperatorRepresentation__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_getOperatorRepresentation__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_getOperatorRepresentation__1" c_casadi_getOperatorRepresentation__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) +casadi_getOperatorRepresentation__1 + :: DMatrix -> Vector String -> IO String +casadi_getOperatorRepresentation__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_getOperatorRepresentation__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_getOperatorRepresentation__2" c_casadi_getOperatorRepresentation__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) +casadi_getOperatorRepresentation__2 + :: IMatrix -> Vector String -> IO String +casadi_getOperatorRepresentation__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_getOperatorRepresentation__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_getOperatorRepresentation__3" c_casadi_getOperatorRepresentation__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString) +casadi_getOperatorRepresentation__3 + :: MX -> Vector String -> IO String +casadi_getOperatorRepresentation__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_getOperatorRepresentation__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gradient__0" c_casadi_gradient__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_gradient__0 + :: SX -> SX -> IO SX +casadi_gradient__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gradient__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gradient__1" c_casadi_gradient__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_gradient__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_gradient__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gradient__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gradient__2" c_casadi_gradient__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_gradient__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_gradient__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gradient__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gradient__3" c_casadi_gradient__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_gradient__3 + :: MX -> MX -> IO MX +casadi_gradient__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gradient__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_graph_substitute__0" c_casadi_graph_substitute__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_graph_substitute__0 + :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) +casadi_graph_substitute__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_graph_substitute__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_graph_substitute__1" c_casadi_graph_substitute__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi_graph_substitute__1 + :: MX -> Vector MX -> Vector MX -> IO MX +casadi_graph_substitute__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_graph_substitute__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gt__0" c_casadi_gt__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_gt__0 + :: SX -> SX -> IO SX +casadi_gt__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gt__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gt__1" c_casadi_gt__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_gt__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_gt__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gt__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gt__2" c_casadi_gt__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_gt__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_gt__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gt__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_gt__3" c_casadi_gt__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_gt__3 + :: MX -> MX -> IO MX +casadi_gt__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_gt__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_heaviside__0" c_casadi_heaviside__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_heaviside__0 + :: SX -> IO SX +casadi_heaviside__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_heaviside__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_heaviside__1" c_casadi_heaviside__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_heaviside__1 + :: DMatrix -> IO DMatrix +casadi_heaviside__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_heaviside__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_heaviside__2" c_casadi_heaviside__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_heaviside__2 + :: IMatrix -> IO IMatrix +casadi_heaviside__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_heaviside__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_hessian__0" c_casadi_hessian__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_hessian__0 + :: SX -> SX -> SX -> IO SX +casadi_hessian__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_hessian__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_hessian__1" c_casadi_hessian__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_hessian__1 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_hessian__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_hessian__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_hessian__2" c_casadi_hessian__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_hessian__2 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_hessian__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_hessian__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_hessian__3" c_casadi_hessian__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_hessian__3 + :: MX -> MX -> MX -> IO MX +casadi_hessian__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_hessian__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzcat__0" c_casadi_horzcat__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') +casadi_horzcat__0 + :: Vector SX -> IO SX +casadi_horzcat__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzcat__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzcat__1" c_casadi_horzcat__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') +casadi_horzcat__1 + :: Vector DMatrix -> IO DMatrix +casadi_horzcat__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzcat__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzcat__2" c_casadi_horzcat__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') +casadi_horzcat__2 + :: Vector IMatrix -> IO IMatrix +casadi_horzcat__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzcat__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzcat__3" c_casadi_horzcat__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi_horzcat__3 + :: Vector MX -> IO MX +casadi_horzcat__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzcat__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzcat__4" c_casadi_horzcat__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') +casadi_horzcat__4 + :: Vector Sparsity -> IO Sparsity +casadi_horzcat__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzcat__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__0" c_casadi_horzsplit__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX'))) +casadi_horzsplit__0 + :: SX -> IO (Vector SX) +casadi_horzsplit__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__1" c_casadi_horzsplit__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi_horzsplit__1 + :: SX -> Int -> IO (Vector SX) +casadi_horzsplit__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__2" c_casadi_horzsplit__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX'))) +casadi_horzsplit__2 + :: SX -> Vector Int -> IO (Vector SX) +casadi_horzsplit__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__3" c_casadi_horzsplit__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_horzsplit__3 + :: DMatrix -> IO (Vector DMatrix) +casadi_horzsplit__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__4" c_casadi_horzsplit__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_horzsplit__4 + :: DMatrix -> Int -> IO (Vector DMatrix) +casadi_horzsplit__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__5" c_casadi_horzsplit__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_horzsplit__5 + :: DMatrix -> Vector Int -> IO (Vector DMatrix) +casadi_horzsplit__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__6" c_casadi_horzsplit__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_horzsplit__6 + :: IMatrix -> IO (Vector IMatrix) +casadi_horzsplit__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__7" c_casadi_horzsplit__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_horzsplit__7 + :: IMatrix -> Int -> IO (Vector IMatrix) +casadi_horzsplit__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__8" c_casadi_horzsplit__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_horzsplit__8 + :: IMatrix -> Vector Int -> IO (Vector IMatrix) +casadi_horzsplit__8 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__8 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__9" c_casadi_horzsplit__9 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) +casadi_horzsplit__9 + :: MX -> IO (Vector MX) +casadi_horzsplit__9 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__9 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__10" c_casadi_horzsplit__10 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi_horzsplit__10 + :: MX -> Int -> IO (Vector MX) +casadi_horzsplit__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__11" c_casadi_horzsplit__11 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_horzsplit__11 + :: MX -> Vector Int -> IO (Vector MX) +casadi_horzsplit__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__12" c_casadi_horzsplit__12 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_horzsplit__12 + :: Sparsity -> IO (Vector Sparsity) +casadi_horzsplit__12 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__12 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__13" c_casadi_horzsplit__13 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_horzsplit__13 + :: Sparsity -> Int -> IO (Vector Sparsity) +casadi_horzsplit__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_horzsplit__14" c_casadi_horzsplit__14 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_horzsplit__14 + :: Sparsity -> Vector Int -> IO (Vector Sparsity) +casadi_horzsplit__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_horzsplit__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__0" c_casadi_if_else__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_if_else__0 + :: SX -> SX -> SX -> IO SX +casadi_if_else__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__1" c_casadi_if_else__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_if_else__1 + :: SX -> SX -> SX -> Bool -> IO SX +casadi_if_else__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__2" c_casadi_if_else__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_if_else__2 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_if_else__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__3" c_casadi_if_else__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_if_else__3 + :: DMatrix -> DMatrix -> DMatrix -> Bool -> IO DMatrix +casadi_if_else__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__4" c_casadi_if_else__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_if_else__4 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_if_else__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__5" c_casadi_if_else__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_if_else__5 + :: IMatrix -> IMatrix -> IMatrix -> Bool -> IO IMatrix +casadi_if_else__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__6" c_casadi_if_else__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_if_else__6 + :: MX -> MX -> MX -> IO MX +casadi_if_else__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_if_else__7" c_casadi_if_else__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_if_else__7 + :: MX -> MX -> MX -> Bool -> IO MX +casadi_if_else__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_if_else__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inner_prod__0" c_casadi_inner_prod__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_inner_prod__0 + :: SX -> SX -> IO SX +casadi_inner_prod__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inner_prod__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inner_prod__1" c_casadi_inner_prod__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_inner_prod__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_inner_prod__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inner_prod__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inner_prod__2" c_casadi_inner_prod__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_inner_prod__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_inner_prod__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inner_prod__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inner_prod__3" c_casadi_inner_prod__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_inner_prod__3 + :: MX -> MX -> IO MX +casadi_inner_prod__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inner_prod__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inv__0" c_casadi_inv__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_inv__0 + :: SX -> IO SX +casadi_inv__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inv__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inv__1" c_casadi_inv__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_inv__1 + :: DMatrix -> IO DMatrix +casadi_inv__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inv__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inv__2" c_casadi_inv__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_inv__2 + :: IMatrix -> IO IMatrix +casadi_inv__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inv__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_inv__3" c_casadi_inv__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_inv__3 + :: MX -> IO MX +casadi_inv__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_inv__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__0" c_casadi_isEqual__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt +casadi_isEqual__0 + :: SX -> SX -> IO Bool +casadi_isEqual__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__1" c_casadi_isEqual__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO CInt +casadi_isEqual__1 + :: SX -> SX -> Int -> IO Bool +casadi_isEqual__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__2" c_casadi_isEqual__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt +casadi_isEqual__2 + :: DMatrix -> DMatrix -> IO Bool +casadi_isEqual__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__3" c_casadi_isEqual__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO CInt +casadi_isEqual__3 + :: DMatrix -> DMatrix -> Int -> IO Bool +casadi_isEqual__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__4" c_casadi_isEqual__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt +casadi_isEqual__4 + :: IMatrix -> IMatrix -> IO Bool +casadi_isEqual__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__5" c_casadi_isEqual__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO CInt +casadi_isEqual__5 + :: IMatrix -> IMatrix -> Int -> IO Bool +casadi_isEqual__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__6" c_casadi_isEqual__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt +casadi_isEqual__6 + :: MX -> MX -> IO Bool +casadi_isEqual__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_isEqual__7" c_casadi_isEqual__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO CInt +casadi_isEqual__7 + :: MX -> MX -> Int -> IO Bool +casadi_isEqual__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_isEqual__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_iszero__0" c_casadi_iszero__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi_iszero__0 + :: SX -> IO Bool +casadi_iszero__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_iszero__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_iszero__1" c_casadi_iszero__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi_iszero__1 + :: DMatrix -> IO Bool +casadi_iszero__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_iszero__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_iszero__2" c_casadi_iszero__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi_iszero__2 + :: IMatrix -> IO Bool +casadi_iszero__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_iszero__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_iszero__3" c_casadi_iszero__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi_iszero__3 + :: MX -> IO Bool +casadi_iszero__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_iszero__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobian__0" c_casadi_jacobian__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_jacobian__0 + :: SX -> SX -> IO SX +casadi_jacobian__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobian__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobian__1" c_casadi_jacobian__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_jacobian__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_jacobian__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobian__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobian__2" c_casadi_jacobian__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_jacobian__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_jacobian__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobian__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobian__3" c_casadi_jacobian__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_jacobian__3 + :: MX -> MX -> IO MX +casadi_jacobian__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobian__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobianTimesVector__0" c_casadi_jacobianTimesVector__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_jacobianTimesVector__0 + :: SX -> SX -> SX -> IO SX +casadi_jacobianTimesVector__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobianTimesVector__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobianTimesVector__1" c_casadi_jacobianTimesVector__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_jacobianTimesVector__1 + :: SX -> SX -> SX -> Bool -> IO SX +casadi_jacobianTimesVector__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobianTimesVector__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobianTimesVector__2" c_casadi_jacobianTimesVector__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_jacobianTimesVector__2 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_jacobianTimesVector__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobianTimesVector__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobianTimesVector__3" c_casadi_jacobianTimesVector__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_jacobianTimesVector__3 + :: DMatrix -> DMatrix -> DMatrix -> Bool -> IO DMatrix +casadi_jacobianTimesVector__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobianTimesVector__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobianTimesVector__4" c_casadi_jacobianTimesVector__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_jacobianTimesVector__4 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_jacobianTimesVector__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobianTimesVector__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_jacobianTimesVector__5" c_casadi_jacobianTimesVector__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_jacobianTimesVector__5 + :: IMatrix -> IMatrix -> IMatrix -> Bool -> IO IMatrix +casadi_jacobianTimesVector__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_jacobianTimesVector__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_kron__0" c_casadi_kron__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_kron__0 + :: SX -> SX -> IO SX +casadi_kron__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_kron__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_kron__1" c_casadi_kron__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_kron__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_kron__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_kron__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_kron__2" c_casadi_kron__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_kron__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_kron__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_kron__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_kron__3" c_casadi_kron__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_kron__3 + :: MX -> MX -> IO MX +casadi_kron__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_kron__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_kron__4" c_casadi_kron__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_kron__4 + :: Sparsity -> Sparsity -> IO Sparsity +casadi_kron__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_kron__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ldivide__0" c_casadi_ldivide__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_ldivide__0 + :: SX -> SX -> IO SX +casadi_ldivide__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ldivide__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ldivide__1" c_casadi_ldivide__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_ldivide__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_ldivide__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ldivide__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ldivide__2" c_casadi_ldivide__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_ldivide__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_ldivide__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ldivide__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ldivide__3" c_casadi_ldivide__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_ldivide__3 + :: MX -> MX -> IO MX +casadi_ldivide__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ldivide__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_le__0" c_casadi_le__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_le__0 + :: SX -> SX -> IO SX +casadi_le__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_le__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_le__1" c_casadi_le__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_le__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_le__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_le__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_le__2" c_casadi_le__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_le__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_le__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_le__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_le__3" c_casadi_le__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_le__3 + :: MX -> MX -> IO MX +casadi_le__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_le__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_linspace__0" c_casadi_linspace__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_linspace__0 + :: SX -> SX -> Int -> IO SX +casadi_linspace__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_linspace__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_linspace__1" c_casadi_linspace__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_linspace__1 + :: DMatrix -> DMatrix -> Int -> IO DMatrix +casadi_linspace__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_linspace__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_linspace__2" c_casadi_linspace__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_linspace__2 + :: IMatrix -> IMatrix -> Int -> IO IMatrix +casadi_linspace__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_linspace__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_linspace__3" c_casadi_linspace__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_linspace__3 + :: MX -> MX -> Int -> IO MX +casadi_linspace__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_linspace__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log__0" c_casadi_log__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_log__0 + :: SX -> IO SX +casadi_log__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log__1" c_casadi_log__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_log__1 + :: DMatrix -> IO DMatrix +casadi_log__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log__2" c_casadi_log__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_log__2 + :: IMatrix -> IO IMatrix +casadi_log__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log__3" c_casadi_log__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_log__3 + :: MX -> IO MX +casadi_log__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log10__0" c_casadi_log10__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_log10__0 + :: SX -> IO SX +casadi_log10__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log10__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log10__1" c_casadi_log10__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_log10__1 + :: DMatrix -> IO DMatrix +casadi_log10__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log10__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log10__2" c_casadi_log10__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_log10__2 + :: IMatrix -> IO IMatrix +casadi_log10__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log10__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_log10__3" c_casadi_log10__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_log10__3 + :: MX -> IO MX +casadi_log10__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_log10__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_lt__0" c_casadi_lt__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_lt__0 + :: SX -> SX -> IO SX +casadi_lt__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_lt__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_lt__1" c_casadi_lt__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_lt__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_lt__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_lt__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_lt__2" c_casadi_lt__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_lt__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_lt__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_lt__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_lt__3" c_casadi_lt__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_lt__3 + :: MX -> MX -> IO MX +casadi_lt__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_lt__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mac__0" c_casadi_mac__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_mac__0 + :: SX -> SX -> SX -> IO SX +casadi_mac__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mac__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mac__1" c_casadi_mac__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_mac__1 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_mac__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mac__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mac__2" c_casadi_mac__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_mac__2 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_mac__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mac__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mac__3" c_casadi_mac__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_mac__3 + :: MX -> MX -> MX -> IO MX +casadi_mac__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mac__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mac__4" c_casadi_mac__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_mac__4 + :: Sparsity -> Sparsity -> Sparsity -> IO Sparsity +casadi_mac__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mac__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_matrix_expand__0" c_casadi_matrix_expand__0 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_matrix_expand__0 + :: MX -> IO MX +casadi_matrix_expand__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_matrix_expand__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_matrix_expand__1" c_casadi_matrix_expand__1 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi_matrix_expand__1 + :: MX -> Vector MX -> IO MX +casadi_matrix_expand__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_matrix_expand__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_matrix_expand__2" c_casadi_matrix_expand__2 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX') +casadi_matrix_expand__2 + :: MX -> Vector MX -> M.Map String GenericType -> IO MX +casadi_matrix_expand__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_matrix_expand__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_matrix_expand__3" c_casadi_matrix_expand__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_matrix_expand__3 + :: Vector MX -> IO (Vector MX) +casadi_matrix_expand__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_matrix_expand__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_matrix_expand__4" c_casadi_matrix_expand__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_matrix_expand__4 + :: Vector MX -> Vector MX -> IO (Vector MX) +casadi_matrix_expand__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_matrix_expand__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_matrix_expand__5" c_casadi_matrix_expand__5 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_matrix_expand__5 + :: Vector MX -> Vector MX -> M.Map String GenericType -> IO (Vector MX) +casadi_matrix_expand__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_matrix_expand__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_max__0" c_casadi_max__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_max__0 + :: SX -> SX -> IO SX +casadi_max__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_max__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_max__1" c_casadi_max__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_max__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_max__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_max__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_max__2" c_casadi_max__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_max__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_max__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_max__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_max__3" c_casadi_max__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_max__3 + :: MX -> MX -> IO MX +casadi_max__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_max__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_min__0" c_casadi_min__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_min__0 + :: SX -> SX -> IO SX +casadi_min__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_min__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_min__1" c_casadi_min__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_min__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_min__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_min__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_min__2" c_casadi_min__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_min__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_min__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_min__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_min__3" c_casadi_min__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_min__3 + :: MX -> MX -> IO MX +casadi_min__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_min__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_minus__0" c_casadi_minus__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_minus__0 + :: SX -> SX -> IO SX +casadi_minus__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_minus__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_minus__1" c_casadi_minus__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_minus__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_minus__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_minus__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_minus__2" c_casadi_minus__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_minus__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_minus__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_minus__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_minus__3" c_casadi_minus__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_minus__3 + :: MX -> MX -> IO MX +casadi_minus__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_minus__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mldivide__0" c_casadi_mldivide__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_mldivide__0 + :: SX -> SX -> IO SX +casadi_mldivide__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mldivide__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mldivide__1" c_casadi_mldivide__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_mldivide__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_mldivide__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mldivide__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mldivide__2" c_casadi_mldivide__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_mldivide__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_mldivide__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mldivide__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mldivide__3" c_casadi_mldivide__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_mldivide__3 + :: MX -> MX -> IO MX +casadi_mldivide__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mldivide__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mod__0" c_casadi_mod__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_mod__0 + :: SX -> SX -> IO SX +casadi_mod__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mod__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mod__1" c_casadi_mod__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_mod__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_mod__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mod__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mod__2" c_casadi_mod__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_mod__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_mod__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mod__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mod__3" c_casadi_mod__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_mod__3 + :: MX -> MX -> IO MX +casadi_mod__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mod__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mpower__0" c_casadi_mpower__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_mpower__0 + :: SX -> SX -> IO SX +casadi_mpower__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mpower__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mpower__1" c_casadi_mpower__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_mpower__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_mpower__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mpower__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mpower__2" c_casadi_mpower__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_mpower__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_mpower__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mpower__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mpower__3" c_casadi_mpower__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_mpower__3 + :: MX -> MX -> IO MX +casadi_mpower__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mpower__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mrdivide__0" c_casadi_mrdivide__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_mrdivide__0 + :: SX -> SX -> IO SX +casadi_mrdivide__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mrdivide__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mrdivide__1" c_casadi_mrdivide__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_mrdivide__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_mrdivide__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mrdivide__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mrdivide__2" c_casadi_mrdivide__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_mrdivide__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_mrdivide__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mrdivide__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mrdivide__3" c_casadi_mrdivide__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_mrdivide__3 + :: MX -> MX -> IO MX +casadi_mrdivide__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mrdivide__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__0" c_casadi_mtaylor__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr SX') +casadi_mtaylor__0 + :: SX -> SX -> SX -> Int -> Vector Int -> IO SX +casadi_mtaylor__0 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__0 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__1" c_casadi_mtaylor__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_mtaylor__1 + :: SX -> SX -> SX -> IO SX +casadi_mtaylor__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__2" c_casadi_mtaylor__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_mtaylor__2 + :: SX -> SX -> SX -> Int -> IO SX +casadi_mtaylor__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__3" c_casadi_mtaylor__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr DMatrix') +casadi_mtaylor__3 + :: DMatrix -> DMatrix -> DMatrix -> Int -> Vector Int -> IO DMatrix +casadi_mtaylor__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__4" c_casadi_mtaylor__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_mtaylor__4 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_mtaylor__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__5" c_casadi_mtaylor__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_mtaylor__5 + :: DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix +casadi_mtaylor__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__6" c_casadi_mtaylor__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr IMatrix') +casadi_mtaylor__6 + :: IMatrix -> IMatrix -> IMatrix -> Int -> Vector Int -> IO IMatrix +casadi_mtaylor__6 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__6 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__7" c_casadi_mtaylor__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_mtaylor__7 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_mtaylor__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mtaylor__8" c_casadi_mtaylor__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_mtaylor__8 + :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix +casadi_mtaylor__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mtaylor__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__0" c_casadi_mul__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') +casadi_mul__0 + :: Vector SX -> IO SX +casadi_mul__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__1" c_casadi_mul__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_mul__1 + :: SX -> SX -> IO SX +casadi_mul__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__2" c_casadi_mul__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') +casadi_mul__2 + :: Vector DMatrix -> IO DMatrix +casadi_mul__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__3" c_casadi_mul__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_mul__3 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_mul__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__4" c_casadi_mul__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') +casadi_mul__4 + :: Vector IMatrix -> IO IMatrix +casadi_mul__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__5" c_casadi_mul__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_mul__5 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_mul__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__6" c_casadi_mul__6 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi_mul__6 + :: Vector MX -> IO MX +casadi_mul__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__7" c_casadi_mul__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_mul__7 + :: MX -> MX -> IO MX +casadi_mul__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__8" c_casadi_mul__8 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') +casadi_mul__8 + :: Vector Sparsity -> IO Sparsity +casadi_mul__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_mul__9" c_casadi_mul__9 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_mul__9 + :: Sparsity -> Sparsity -> IO Sparsity +casadi_mul__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_mul__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ne__0" c_casadi_ne__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_ne__0 + :: SX -> SX -> IO SX +casadi_ne__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ne__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ne__1" c_casadi_ne__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_ne__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_ne__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ne__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ne__2" c_casadi_ne__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_ne__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_ne__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ne__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ne__3" c_casadi_ne__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_ne__3 + :: MX -> MX -> IO MX +casadi_ne__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ne__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_0_mul__0" c_casadi_norm_0_mul__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt +casadi_norm_0_mul__0 + :: SX -> SX -> IO Int +casadi_norm_0_mul__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_0_mul__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_0_mul__1" c_casadi_norm_0_mul__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt +casadi_norm_0_mul__1 + :: DMatrix -> DMatrix -> IO Int +casadi_norm_0_mul__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_0_mul__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_0_mul__2" c_casadi_norm_0_mul__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt +casadi_norm_0_mul__2 + :: IMatrix -> IMatrix -> IO Int +casadi_norm_0_mul__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_0_mul__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_0_mul__3" c_casadi_norm_0_mul__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt +casadi_norm_0_mul__3 + :: MX -> MX -> IO Int +casadi_norm_0_mul__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_0_mul__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_0_mul__4" c_casadi_norm_0_mul__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO CInt +casadi_norm_0_mul__4 + :: Sparsity -> Sparsity -> IO Int +casadi_norm_0_mul__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_0_mul__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_1__0" c_casadi_norm_1__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_norm_1__0 + :: SX -> IO SX +casadi_norm_1__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_1__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_1__1" c_casadi_norm_1__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_norm_1__1 + :: DMatrix -> IO DMatrix +casadi_norm_1__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_1__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_1__2" c_casadi_norm_1__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_norm_1__2 + :: IMatrix -> IO IMatrix +casadi_norm_1__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_1__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_1__3" c_casadi_norm_1__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_norm_1__3 + :: MX -> IO MX +casadi_norm_1__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_1__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_2__0" c_casadi_norm_2__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_norm_2__0 + :: SX -> IO SX +casadi_norm_2__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_2__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_2__1" c_casadi_norm_2__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_norm_2__1 + :: DMatrix -> IO DMatrix +casadi_norm_2__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_2__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_2__2" c_casadi_norm_2__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_norm_2__2 + :: IMatrix -> IO IMatrix +casadi_norm_2__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_2__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_2__3" c_casadi_norm_2__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_norm_2__3 + :: MX -> IO MX +casadi_norm_2__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_2__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_F__0" c_casadi_norm_F__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_norm_F__0 + :: SX -> IO SX +casadi_norm_F__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_F__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_F__1" c_casadi_norm_F__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_norm_F__1 + :: DMatrix -> IO DMatrix +casadi_norm_F__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_F__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_F__2" c_casadi_norm_F__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_norm_F__2 + :: IMatrix -> IO IMatrix +casadi_norm_F__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_F__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_F__3" c_casadi_norm_F__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_norm_F__3 + :: MX -> IO MX +casadi_norm_F__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_F__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_inf__0" c_casadi_norm_inf__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_norm_inf__0 + :: SX -> IO SX +casadi_norm_inf__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_inf__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_inf__1" c_casadi_norm_inf__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_norm_inf__1 + :: DMatrix -> IO DMatrix +casadi_norm_inf__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_inf__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_inf__2" c_casadi_norm_inf__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_norm_inf__2 + :: IMatrix -> IO IMatrix +casadi_norm_inf__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_inf__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_inf__3" c_casadi_norm_inf__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_norm_inf__3 + :: MX -> IO MX +casadi_norm_inf__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_inf__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_inf_mul__0" c_casadi_norm_inf_mul__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_norm_inf_mul__0 + :: SX -> SX -> IO SX +casadi_norm_inf_mul__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_inf_mul__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_inf_mul__1" c_casadi_norm_inf_mul__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_norm_inf_mul__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_norm_inf_mul__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_inf_mul__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_norm_inf_mul__2" c_casadi_norm_inf_mul__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_norm_inf_mul__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_norm_inf_mul__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_norm_inf_mul__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_not__0" c_casadi_not__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_not__0 + :: SX -> IO SX +casadi_not__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_not__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_not__1" c_casadi_not__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_not__1 + :: DMatrix -> IO DMatrix +casadi_not__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_not__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_not__2" c_casadi_not__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_not__2 + :: IMatrix -> IO IMatrix +casadi_not__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_not__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_not__3" c_casadi_not__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_not__3 + :: MX -> IO MX +casadi_not__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_not__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_nullspace__0" c_casadi_nullspace__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_nullspace__0 + :: SX -> IO SX +casadi_nullspace__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_nullspace__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_nullspace__1" c_casadi_nullspace__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_nullspace__1 + :: DMatrix -> IO DMatrix +casadi_nullspace__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_nullspace__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_nullspace__2" c_casadi_nullspace__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_nullspace__2 + :: IMatrix -> IO IMatrix +casadi_nullspace__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_nullspace__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_nullspace__3" c_casadi_nullspace__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_nullspace__3 + :: MX -> IO MX +casadi_nullspace__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_nullspace__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__0" c_casadi_offset__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec CInt)) +casadi_offset__0 + :: Vector SX -> IO (Vector Int) +casadi_offset__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__1" c_casadi_offset__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO (Ptr (StdVec CInt)) +casadi_offset__1 + :: Vector SX -> Bool -> IO (Vector Int) +casadi_offset__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__2" c_casadi_offset__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec CInt)) +casadi_offset__2 + :: Vector DMatrix -> IO (Vector Int) +casadi_offset__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__3" c_casadi_offset__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO (Ptr (StdVec CInt)) +casadi_offset__3 + :: Vector DMatrix -> Bool -> IO (Vector Int) +casadi_offset__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__4" c_casadi_offset__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec CInt)) +casadi_offset__4 + :: Vector IMatrix -> IO (Vector Int) +casadi_offset__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__5" c_casadi_offset__5 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> CInt -> IO (Ptr (StdVec CInt)) +casadi_offset__5 + :: Vector IMatrix -> Bool -> IO (Vector Int) +casadi_offset__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__6" c_casadi_offset__6 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec CInt)) +casadi_offset__6 + :: Vector MX -> IO (Vector Int) +casadi_offset__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__7" c_casadi_offset__7 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO (Ptr (StdVec CInt)) +casadi_offset__7 + :: Vector MX -> Bool -> IO (Vector Int) +casadi_offset__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__8" c_casadi_offset__8 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec CInt)) +casadi_offset__8 + :: Vector Sparsity -> IO (Vector Int) +casadi_offset__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_offset__9" c_casadi_offset__9 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> CInt -> IO (Ptr (StdVec CInt)) +casadi_offset__9 + :: Vector Sparsity -> Bool -> IO (Vector Int) +casadi_offset__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_offset__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_or__0" c_casadi_or__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_or__0 + :: SX -> SX -> IO SX +casadi_or__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_or__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_or__1" c_casadi_or__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_or__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_or__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_or__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_or__2" c_casadi_or__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_or__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_or__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_or__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_or__3" c_casadi_or__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_or__3 + :: MX -> MX -> IO MX +casadi_or__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_or__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_outer_prod__0" c_casadi_outer_prod__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_outer_prod__0 + :: SX -> SX -> IO SX +casadi_outer_prod__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_outer_prod__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_outer_prod__1" c_casadi_outer_prod__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_outer_prod__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_outer_prod__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_outer_prod__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_outer_prod__2" c_casadi_outer_prod__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_outer_prod__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_outer_prod__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_outer_prod__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_outer_prod__3" c_casadi_outer_prod__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_outer_prod__3 + :: MX -> MX -> IO MX +casadi_outer_prod__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_outer_prod__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__0" c_casadi_pinv__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr StdString -> IO (Ptr SX') +casadi_pinv__0 + :: SX -> String -> IO SX +casadi_pinv__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__1" c_casadi_pinv__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SX') +casadi_pinv__1 + :: SX -> String -> M.Map String GenericType -> IO SX +casadi_pinv__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__2" c_casadi_pinv__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_pinv__2 + :: SX -> IO SX +casadi_pinv__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__3" c_casadi_pinv__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix') +casadi_pinv__3 + :: DMatrix -> String -> IO DMatrix +casadi_pinv__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__4" c_casadi_pinv__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DMatrix') +casadi_pinv__4 + :: DMatrix -> String -> M.Map String GenericType -> IO DMatrix +casadi_pinv__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__5" c_casadi_pinv__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_pinv__5 + :: DMatrix -> IO DMatrix +casadi_pinv__5 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__5 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__6" c_casadi_pinv__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr StdString -> IO (Ptr IMatrix') +casadi_pinv__6 + :: IMatrix -> String -> IO IMatrix +casadi_pinv__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__7" c_casadi_pinv__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr IMatrix') +casadi_pinv__7 + :: IMatrix -> String -> M.Map String GenericType -> IO IMatrix +casadi_pinv__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__8" c_casadi_pinv__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_pinv__8 + :: IMatrix -> IO IMatrix +casadi_pinv__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__9" c_casadi_pinv__9 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') +casadi_pinv__9 + :: MX -> String -> IO MX +casadi_pinv__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__10" c_casadi_pinv__10 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX') +casadi_pinv__10 + :: MX -> String -> M.Map String GenericType -> IO MX +casadi_pinv__10 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__10 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pinv__11" c_casadi_pinv__11 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_pinv__11 + :: MX -> IO MX +casadi_pinv__11 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pinv__11 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_plus__0" c_casadi_plus__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_plus__0 + :: SX -> SX -> IO SX +casadi_plus__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_plus__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_plus__1" c_casadi_plus__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_plus__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_plus__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_plus__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_plus__2" c_casadi_plus__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_plus__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_plus__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_plus__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_plus__3" c_casadi_plus__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_plus__3 + :: MX -> MX -> IO MX +casadi_plus__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_plus__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_poly_coeff__0" c_casadi_poly_coeff__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_poly_coeff__0 + :: SX -> SX -> IO SX +casadi_poly_coeff__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_poly_coeff__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_poly_coeff__1" c_casadi_poly_coeff__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_poly_coeff__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_poly_coeff__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_poly_coeff__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_poly_coeff__2" c_casadi_poly_coeff__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_poly_coeff__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_poly_coeff__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_poly_coeff__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_poly_roots__0" c_casadi_poly_roots__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_poly_roots__0 + :: SX -> IO SX +casadi_poly_roots__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_poly_roots__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_poly_roots__1" c_casadi_poly_roots__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_poly_roots__1 + :: DMatrix -> IO DMatrix +casadi_poly_roots__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_poly_roots__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_poly_roots__2" c_casadi_poly_roots__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_poly_roots__2 + :: IMatrix -> IO IMatrix +casadi_poly_roots__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_poly_roots__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_polyval__0" c_casadi_polyval__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_polyval__0 + :: SX -> SX -> IO SX +casadi_polyval__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_polyval__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_polyval__1" c_casadi_polyval__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_polyval__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_polyval__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_polyval__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_polyval__2" c_casadi_polyval__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_polyval__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_polyval__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_polyval__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_polyval__3" c_casadi_polyval__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_polyval__3 + :: MX -> MX -> IO MX +casadi_polyval__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_polyval__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_power__0" c_casadi_power__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_power__0 + :: SX -> SX -> IO SX +casadi_power__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_power__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_power__1" c_casadi_power__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_power__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_power__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_power__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_power__2" c_casadi_power__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_power__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_power__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_power__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_power__3" c_casadi_power__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_power__3 + :: MX -> MX -> IO MX +casadi_power__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_power__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__0" c_casadi_project__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') +casadi_project__0 + :: SX -> Sparsity -> IO SX +casadi_project__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__1" c_casadi_project__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> CInt -> IO (Ptr SX') +casadi_project__1 + :: SX -> Sparsity -> Bool -> IO SX +casadi_project__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__2" c_casadi_project__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi_project__2 + :: DMatrix -> Sparsity -> IO DMatrix +casadi_project__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__3" c_casadi_project__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr DMatrix') +casadi_project__3 + :: DMatrix -> Sparsity -> Bool -> IO DMatrix +casadi_project__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__4" c_casadi_project__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi_project__4 + :: IMatrix -> Sparsity -> IO IMatrix +casadi_project__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__5" c_casadi_project__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> CInt -> IO (Ptr IMatrix') +casadi_project__5 + :: IMatrix -> Sparsity -> Bool -> IO IMatrix +casadi_project__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__6" c_casadi_project__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') +casadi_project__6 + :: MX -> Sparsity -> IO MX +casadi_project__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_project__7" c_casadi_project__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> CInt -> IO (Ptr MX') +casadi_project__7 + :: MX -> Sparsity -> Bool -> IO MX +casadi_project__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_project__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pw_const__0" c_casadi_pw_const__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_pw_const__0 + :: SX -> SX -> SX -> IO SX +casadi_pw_const__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pw_const__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pw_const__1" c_casadi_pw_const__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_pw_const__1 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_pw_const__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pw_const__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pw_const__2" c_casadi_pw_const__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_pw_const__2 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_pw_const__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pw_const__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pw_lin__0" c_casadi_pw_lin__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_pw_lin__0 + :: SX -> SX -> SX -> IO SX +casadi_pw_lin__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pw_lin__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pw_lin__1" c_casadi_pw_lin__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_pw_lin__1 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_pw_lin__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pw_lin__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_pw_lin__2" c_casadi_pw_lin__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_pw_lin__2 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_pw_lin__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_pw_lin__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_qr__0" c_casadi_qr__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO () +casadi_qr__0 + :: SX -> SX -> SX -> IO () +casadi_qr__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_qr__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_qr__1" c_casadi_qr__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO () +casadi_qr__1 + :: DMatrix -> DMatrix -> DMatrix -> IO () +casadi_qr__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_qr__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_qr__2" c_casadi_qr__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO () +casadi_qr__2 + :: IMatrix -> IMatrix -> IMatrix -> IO () +casadi_qr__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_qr__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__0" c_casadi_quad_form__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_quad_form__0 + :: SX -> IO SX +casadi_quad_form__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__1" c_casadi_quad_form__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_quad_form__1 + :: SX -> SX -> IO SX +casadi_quad_form__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__2" c_casadi_quad_form__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_quad_form__2 + :: DMatrix -> IO DMatrix +casadi_quad_form__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__3" c_casadi_quad_form__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_quad_form__3 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_quad_form__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__4" c_casadi_quad_form__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_quad_form__4 + :: IMatrix -> IO IMatrix +casadi_quad_form__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__5" c_casadi_quad_form__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_quad_form__5 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_quad_form__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__6" c_casadi_quad_form__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_quad_form__6 + :: MX -> IO MX +casadi_quad_form__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_quad_form__7" c_casadi_quad_form__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_quad_form__7 + :: MX -> MX -> IO MX +casadi_quad_form__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_quad_form__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ramp__0" c_casadi_ramp__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_ramp__0 + :: SX -> IO SX +casadi_ramp__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ramp__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ramp__1" c_casadi_ramp__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_ramp__1 + :: DMatrix -> IO DMatrix +casadi_ramp__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ramp__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_ramp__2" c_casadi_ramp__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_ramp__2 + :: IMatrix -> IO IMatrix +casadi_ramp__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_ramp__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_rdivide__0" c_casadi_rdivide__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_rdivide__0 + :: SX -> SX -> IO SX +casadi_rdivide__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_rdivide__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_rdivide__1" c_casadi_rdivide__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_rdivide__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_rdivide__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_rdivide__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_rdivide__2" c_casadi_rdivide__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_rdivide__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_rdivide__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_rdivide__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_rdivide__3" c_casadi_rdivide__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_rdivide__3 + :: MX -> MX -> IO MX +casadi_rdivide__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_rdivide__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_rectangle__0" c_casadi_rectangle__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_rectangle__0 + :: SX -> IO SX +casadi_rectangle__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_rectangle__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_rectangle__1" c_casadi_rectangle__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_rectangle__1 + :: DMatrix -> IO DMatrix +casadi_rectangle__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_rectangle__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_rectangle__2" c_casadi_rectangle__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_rectangle__2 + :: IMatrix -> IO IMatrix +casadi_rectangle__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_rectangle__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__0" c_casadi_repmat__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi_repmat__0 + :: SX -> (Int, Int) -> IO SX +casadi_repmat__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__1" c_casadi_repmat__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_repmat__1 + :: SX -> Int -> IO SX +casadi_repmat__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__2" c_casadi_repmat__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') +casadi_repmat__2 + :: SX -> Int -> Int -> IO SX +casadi_repmat__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__3" c_casadi_repmat__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi_repmat__3 + :: DMatrix -> (Int, Int) -> IO DMatrix +casadi_repmat__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__4" c_casadi_repmat__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_repmat__4 + :: DMatrix -> Int -> IO DMatrix +casadi_repmat__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__5" c_casadi_repmat__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') +casadi_repmat__5 + :: DMatrix -> Int -> Int -> IO DMatrix +casadi_repmat__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__6" c_casadi_repmat__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi_repmat__6 + :: IMatrix -> (Int, Int) -> IO IMatrix +casadi_repmat__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__7" c_casadi_repmat__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_repmat__7 + :: IMatrix -> Int -> IO IMatrix +casadi_repmat__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__8" c_casadi_repmat__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') +casadi_repmat__8 + :: IMatrix -> Int -> Int -> IO IMatrix +casadi_repmat__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__9" c_casadi_repmat__9 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi_repmat__9 + :: MX -> (Int, Int) -> IO MX +casadi_repmat__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__10" c_casadi_repmat__10 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_repmat__10 + :: MX -> Int -> IO MX +casadi_repmat__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__11" c_casadi_repmat__11 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX') +casadi_repmat__11 + :: MX -> Int -> Int -> IO MX +casadi_repmat__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__12" c_casadi_repmat__12 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity') +casadi_repmat__12 + :: Sparsity -> (Int, Int) -> IO Sparsity +casadi_repmat__12 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__12 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__13" c_casadi_repmat__13 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi_repmat__13 + :: Sparsity -> Int -> IO Sparsity +casadi_repmat__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repmat__14" c_casadi_repmat__14 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') +casadi_repmat__14 + :: Sparsity -> Int -> Int -> IO Sparsity +casadi_repmat__14 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repmat__14 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__0" c_casadi_repsum__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_repsum__0 + :: SX -> Int -> IO SX +casadi_repsum__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__1" c_casadi_repsum__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') +casadi_repsum__1 + :: SX -> Int -> Int -> IO SX +casadi_repsum__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__2" c_casadi_repsum__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_repsum__2 + :: DMatrix -> Int -> IO DMatrix +casadi_repsum__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__3" c_casadi_repsum__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') +casadi_repsum__3 + :: DMatrix -> Int -> Int -> IO DMatrix +casadi_repsum__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__4" c_casadi_repsum__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_repsum__4 + :: IMatrix -> Int -> IO IMatrix +casadi_repsum__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__5" c_casadi_repsum__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') +casadi_repsum__5 + :: IMatrix -> Int -> Int -> IO IMatrix +casadi_repsum__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__6" c_casadi_repsum__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_repsum__6 + :: MX -> Int -> IO MX +casadi_repsum__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_repsum__7" c_casadi_repsum__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX') +casadi_repsum__7 + :: MX -> Int -> Int -> IO MX +casadi_repsum__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_repsum__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__0" c_casadi_reshape__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX') +casadi_reshape__0 + :: SX -> Sparsity -> IO SX +casadi_reshape__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__1" c_casadi_reshape__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdPair CInt CInt) -> IO (Ptr SX') +casadi_reshape__1 + :: SX -> (Int, Int) -> IO SX +casadi_reshape__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__2" c_casadi_reshape__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX') +casadi_reshape__2 + :: SX -> Int -> Int -> IO SX +casadi_reshape__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__3" c_casadi_reshape__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix') +casadi_reshape__3 + :: DMatrix -> Sparsity -> IO DMatrix +casadi_reshape__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__4" c_casadi_reshape__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr DMatrix') +casadi_reshape__4 + :: DMatrix -> (Int, Int) -> IO DMatrix +casadi_reshape__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__5" c_casadi_reshape__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix') +casadi_reshape__5 + :: DMatrix -> Int -> Int -> IO DMatrix +casadi_reshape__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__6" c_casadi_reshape__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix') +casadi_reshape__6 + :: IMatrix -> Sparsity -> IO IMatrix +casadi_reshape__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__7" c_casadi_reshape__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdPair CInt CInt) -> IO (Ptr IMatrix') +casadi_reshape__7 + :: IMatrix -> (Int, Int) -> IO IMatrix +casadi_reshape__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__8" c_casadi_reshape__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix') +casadi_reshape__8 + :: IMatrix -> Int -> Int -> IO IMatrix +casadi_reshape__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__9" c_casadi_reshape__9 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX') +casadi_reshape__9 + :: MX -> Sparsity -> IO MX +casadi_reshape__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__10" c_casadi_reshape__10 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdPair CInt CInt) -> IO (Ptr MX') +casadi_reshape__10 + :: MX -> (Int, Int) -> IO MX +casadi_reshape__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__11" c_casadi_reshape__11 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX') +casadi_reshape__11 + :: MX -> Int -> Int -> IO MX +casadi_reshape__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__12" c_casadi_reshape__12 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_reshape__12 + :: Sparsity -> Sparsity -> IO Sparsity +casadi_reshape__12 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__12 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__13" c_casadi_reshape__13 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdPair CInt CInt) -> IO (Ptr Sparsity') +casadi_reshape__13 + :: Sparsity -> (Int, Int) -> IO Sparsity +casadi_reshape__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_reshape__14" c_casadi_reshape__14 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity') +casadi_reshape__14 + :: Sparsity -> Int -> Int -> IO Sparsity +casadi_reshape__14 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_reshape__14 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sign__0" c_casadi_sign__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sign__0 + :: SX -> IO SX +casadi_sign__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sign__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sign__1" c_casadi_sign__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sign__1 + :: DMatrix -> IO DMatrix +casadi_sign__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sign__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sign__2" c_casadi_sign__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sign__2 + :: IMatrix -> IO IMatrix +casadi_sign__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sign__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sign__3" c_casadi_sign__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_sign__3 + :: MX -> IO MX +casadi_sign__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sign__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_simplify__0" c_casadi_simplify__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_simplify__0 + :: SX -> IO SX +casadi_simplify__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_simplify__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_simplify__1" c_casadi_simplify__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_simplify__1 + :: DMatrix -> IO DMatrix +casadi_simplify__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_simplify__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_simplify__2" c_casadi_simplify__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_simplify__2 + :: IMatrix -> IO IMatrix +casadi_simplify__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_simplify__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_simplify__3" c_casadi_simplify__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_simplify__3 + :: MX -> IO MX +casadi_simplify__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_simplify__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sin__0" c_casadi_sin__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sin__0 + :: SX -> IO SX +casadi_sin__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sin__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sin__1" c_casadi_sin__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sin__1 + :: DMatrix -> IO DMatrix +casadi_sin__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sin__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sin__2" c_casadi_sin__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sin__2 + :: IMatrix -> IO IMatrix +casadi_sin__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sin__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sin__3" c_casadi_sin__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_sin__3 + :: MX -> IO MX +casadi_sin__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sin__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sinh__0" c_casadi_sinh__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sinh__0 + :: SX -> IO SX +casadi_sinh__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sinh__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sinh__1" c_casadi_sinh__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sinh__1 + :: DMatrix -> IO DMatrix +casadi_sinh__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sinh__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sinh__2" c_casadi_sinh__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sinh__2 + :: IMatrix -> IO IMatrix +casadi_sinh__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sinh__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sinh__3" c_casadi_sinh__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_sinh__3 + :: MX -> IO MX +casadi_sinh__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sinh__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__0" c_casadi_solve__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr StdString -> IO (Ptr SX') +casadi_solve__0 + :: SX -> SX -> String -> IO SX +casadi_solve__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__1" c_casadi_solve__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr SX') +casadi_solve__1 + :: SX -> SX -> String -> M.Map String GenericType -> IO SX +casadi_solve__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__2" c_casadi_solve__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_solve__2 + :: SX -> SX -> IO SX +casadi_solve__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__3" c_casadi_solve__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix') +casadi_solve__3 + :: DMatrix -> DMatrix -> String -> IO DMatrix +casadi_solve__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__4" c_casadi_solve__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr DMatrix') +casadi_solve__4 + :: DMatrix -> DMatrix -> String -> M.Map String GenericType -> IO DMatrix +casadi_solve__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__5" c_casadi_solve__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_solve__5 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_solve__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__6" c_casadi_solve__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr StdString -> IO (Ptr IMatrix') +casadi_solve__6 + :: IMatrix -> IMatrix -> String -> IO IMatrix +casadi_solve__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__7" c_casadi_solve__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr IMatrix') +casadi_solve__7 + :: IMatrix -> IMatrix -> String -> M.Map String GenericType -> IO IMatrix +casadi_solve__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__8" c_casadi_solve__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_solve__8 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_solve__8 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__8 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__9" c_casadi_solve__9 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> IO (Ptr MX') +casadi_solve__9 + :: MX -> MX -> String -> IO MX +casadi_solve__9 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__9 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__10" c_casadi_solve__10 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MX') +casadi_solve__10 + :: MX -> MX -> String -> M.Map String GenericType -> IO MX +casadi_solve__10 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__10 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_solve__11" c_casadi_solve__11 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_solve__11 + :: MX -> MX -> IO MX +casadi_solve__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_solve__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sparsify__0" c_casadi_sparsify__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sparsify__0 + :: SX -> IO SX +casadi_sparsify__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sparsify__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sparsify__1" c_casadi_sparsify__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO (Ptr SX') +casadi_sparsify__1 + :: SX -> Double -> IO SX +casadi_sparsify__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sparsify__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sparsify__2" c_casadi_sparsify__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sparsify__2 + :: DMatrix -> IO DMatrix +casadi_sparsify__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sparsify__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sparsify__3" c_casadi_sparsify__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO (Ptr DMatrix') +casadi_sparsify__3 + :: DMatrix -> Double -> IO DMatrix +casadi_sparsify__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sparsify__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sparsify__4" c_casadi_sparsify__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sparsify__4 + :: IMatrix -> IO IMatrix +casadi_sparsify__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sparsify__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sparsify__5" c_casadi_sparsify__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO (Ptr IMatrix') +casadi_sparsify__5 + :: IMatrix -> Double -> IO IMatrix +casadi_sparsify__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sparsify__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sprank__0" c_casadi_sprank__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt +casadi_sprank__0 + :: SX -> IO Int +casadi_sprank__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sprank__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sprank__1" c_casadi_sprank__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt +casadi_sprank__1 + :: DMatrix -> IO Int +casadi_sprank__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sprank__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sprank__2" c_casadi_sprank__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt +casadi_sprank__2 + :: IMatrix -> IO Int +casadi_sprank__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sprank__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sprank__3" c_casadi_sprank__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt +casadi_sprank__3 + :: MX -> IO Int +casadi_sprank__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sprank__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sprank__4" c_casadi_sprank__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt +casadi_sprank__4 + :: Sparsity -> IO Int +casadi_sprank__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sprank__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sqrt__0" c_casadi_sqrt__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sqrt__0 + :: SX -> IO SX +casadi_sqrt__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sqrt__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sqrt__1" c_casadi_sqrt__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sqrt__1 + :: DMatrix -> IO DMatrix +casadi_sqrt__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sqrt__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sqrt__2" c_casadi_sqrt__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sqrt__2 + :: IMatrix -> IO IMatrix +casadi_sqrt__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sqrt__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sqrt__3" c_casadi_sqrt__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_sqrt__3 + :: MX -> IO MX +casadi_sqrt__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sqrt__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__0" c_casadi_substitute__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX'))) +casadi_substitute__0 + :: Vector SX -> Vector SX -> Vector SX -> IO (Vector SX) +casadi_substitute__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__1" c_casadi_substitute__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_substitute__1 + :: SX -> SX -> SX -> IO SX +casadi_substitute__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__2" c_casadi_substitute__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_substitute__2 + :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO (Vector DMatrix) +casadi_substitute__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__3" c_casadi_substitute__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_substitute__3 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_substitute__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__4" c_casadi_substitute__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_substitute__4 + :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO (Vector IMatrix) +casadi_substitute__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__5" c_casadi_substitute__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_substitute__5 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_substitute__5 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__5 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__6" c_casadi_substitute__6 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_substitute__6 + :: Vector MX -> Vector MX -> Vector MX -> IO (Vector MX) +casadi_substitute__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substitute__7" c_casadi_substitute__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_substitute__7 + :: MX -> MX -> MX -> IO MX +casadi_substitute__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substitute__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__0" c_casadi_substituteInPlace__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO () +casadi_substituteInPlace__0 + :: Vector SX -> Vector SX -> Vector SX -> IO () +casadi_substituteInPlace__0 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__0 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__1" c_casadi_substituteInPlace__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO () +casadi_substituteInPlace__1 + :: Vector SX -> Vector SX -> Vector SX -> Bool -> IO () +casadi_substituteInPlace__1 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__1 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__2" c_casadi_substituteInPlace__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> IO () +casadi_substituteInPlace__2 + :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> IO () +casadi_substituteInPlace__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__3" c_casadi_substituteInPlace__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr (StdVec (Ptr DMatrix')) -> CInt -> IO () +casadi_substituteInPlace__3 + :: Vector DMatrix -> Vector DMatrix -> Vector DMatrix -> Bool -> IO () +casadi_substituteInPlace__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__4" c_casadi_substituteInPlace__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> IO () +casadi_substituteInPlace__4 + :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> IO () +casadi_substituteInPlace__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__5" c_casadi_substituteInPlace__5 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> Ptr (StdVec (Ptr IMatrix')) -> CInt -> IO () +casadi_substituteInPlace__5 + :: Vector IMatrix -> Vector IMatrix -> Vector IMatrix -> Bool -> IO () +casadi_substituteInPlace__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__6" c_casadi_substituteInPlace__6 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO () +casadi_substituteInPlace__6 + :: Vector MX -> Vector MX -> Vector MX -> IO () +casadi_substituteInPlace__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_substituteInPlace__7" c_casadi_substituteInPlace__7 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> CInt -> IO () +casadi_substituteInPlace__7 + :: Vector MX -> Vector MX -> Vector MX -> Bool -> IO () +casadi_substituteInPlace__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_substituteInPlace__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumCols__0" c_casadi_sumCols__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sumCols__0 + :: SX -> IO SX +casadi_sumCols__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumCols__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumCols__1" c_casadi_sumCols__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sumCols__1 + :: DMatrix -> IO DMatrix +casadi_sumCols__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumCols__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumCols__2" c_casadi_sumCols__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sumCols__2 + :: IMatrix -> IO IMatrix +casadi_sumCols__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumCols__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumCols__3" c_casadi_sumCols__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_sumCols__3 + :: MX -> IO MX +casadi_sumCols__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumCols__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumRows__0" c_casadi_sumRows__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sumRows__0 + :: SX -> IO SX +casadi_sumRows__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumRows__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumRows__1" c_casadi_sumRows__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sumRows__1 + :: DMatrix -> IO DMatrix +casadi_sumRows__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumRows__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumRows__2" c_casadi_sumRows__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sumRows__2 + :: IMatrix -> IO IMatrix +casadi_sumRows__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumRows__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sumRows__3" c_casadi_sumRows__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_sumRows__3 + :: MX -> IO MX +casadi_sumRows__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sumRows__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sum_square__0" c_casadi_sum_square__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_sum_square__0 + :: SX -> IO SX +casadi_sum_square__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sum_square__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sum_square__1" c_casadi_sum_square__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_sum_square__1 + :: DMatrix -> IO DMatrix +casadi_sum_square__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sum_square__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sum_square__2" c_casadi_sum_square__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_sum_square__2 + :: IMatrix -> IO IMatrix +casadi_sum_square__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sum_square__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_sum_square__3" c_casadi_sum_square__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_sum_square__3 + :: MX -> IO MX +casadi_sum_square__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_sum_square__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_symvar__0" c_casadi_symvar__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX'))) +casadi_symvar__0 + :: SX -> IO (Vector SX) +casadi_symvar__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_symvar__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_symvar__1" c_casadi_symvar__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_symvar__1 + :: DMatrix -> IO (Vector DMatrix) +casadi_symvar__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_symvar__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_symvar__2" c_casadi_symvar__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_symvar__2 + :: IMatrix -> IO (Vector IMatrix) +casadi_symvar__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_symvar__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_symvar__3" c_casadi_symvar__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) +casadi_symvar__3 + :: MX -> IO (Vector MX) +casadi_symvar__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_symvar__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tan__0" c_casadi_tan__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_tan__0 + :: SX -> IO SX +casadi_tan__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tan__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tan__1" c_casadi_tan__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_tan__1 + :: DMatrix -> IO DMatrix +casadi_tan__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tan__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tan__2" c_casadi_tan__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_tan__2 + :: IMatrix -> IO IMatrix +casadi_tan__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tan__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tan__3" c_casadi_tan__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_tan__3 + :: MX -> IO MX +casadi_tan__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tan__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tangent__0" c_casadi_tangent__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_tangent__0 + :: SX -> SX -> IO SX +casadi_tangent__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tangent__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tangent__1" c_casadi_tangent__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_tangent__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_tangent__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tangent__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tangent__2" c_casadi_tangent__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_tangent__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_tangent__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tangent__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tangent__3" c_casadi_tangent__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_tangent__3 + :: MX -> MX -> IO MX +casadi_tangent__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tangent__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tanh__0" c_casadi_tanh__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_tanh__0 + :: SX -> IO SX +casadi_tanh__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tanh__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tanh__1" c_casadi_tanh__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_tanh__1 + :: DMatrix -> IO DMatrix +casadi_tanh__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tanh__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tanh__2" c_casadi_tanh__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_tanh__2 + :: IMatrix -> IO IMatrix +casadi_tanh__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tanh__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tanh__3" c_casadi_tanh__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_tanh__3 + :: MX -> IO MX +casadi_tanh__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tanh__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__0" c_casadi_taylor__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_taylor__0 + :: SX -> SX -> IO SX +casadi_taylor__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__1" c_casadi_taylor__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_taylor__1 + :: SX -> SX -> SX -> IO SX +casadi_taylor__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__2" c_casadi_taylor__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_taylor__2 + :: SX -> SX -> SX -> Int -> IO SX +casadi_taylor__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__3" c_casadi_taylor__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_taylor__3 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_taylor__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__4" c_casadi_taylor__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_taylor__4 + :: DMatrix -> DMatrix -> DMatrix -> IO DMatrix +casadi_taylor__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__5" c_casadi_taylor__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_taylor__5 + :: DMatrix -> DMatrix -> DMatrix -> Int -> IO DMatrix +casadi_taylor__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__6" c_casadi_taylor__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_taylor__6 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_taylor__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__7" c_casadi_taylor__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_taylor__7 + :: IMatrix -> IMatrix -> IMatrix -> IO IMatrix +casadi_taylor__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_taylor__8" c_casadi_taylor__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_taylor__8 + :: IMatrix -> IMatrix -> IMatrix -> Int -> IO IMatrix +casadi_taylor__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_taylor__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_times__0" c_casadi_times__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_times__0 + :: SX -> SX -> IO SX +casadi_times__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_times__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_times__1" c_casadi_times__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_times__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_times__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_times__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_times__2" c_casadi_times__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_times__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_times__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_times__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_times__3" c_casadi_times__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_times__3 + :: MX -> MX -> IO MX +casadi_times__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_times__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_trace__0" c_casadi_trace__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_trace__0 + :: SX -> IO SX +casadi_trace__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_trace__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_trace__1" c_casadi_trace__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_trace__1 + :: DMatrix -> IO DMatrix +casadi_trace__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_trace__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_trace__2" c_casadi_trace__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_trace__2 + :: IMatrix -> IO IMatrix +casadi_trace__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_trace__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_trace__3" c_casadi_trace__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_trace__3 + :: MX -> IO MX +casadi_trace__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_trace__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_transpose__0" c_casadi_transpose__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_transpose__0 + :: SX -> IO SX +casadi_transpose__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_transpose__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_transpose__1" c_casadi_transpose__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_transpose__1 + :: DMatrix -> IO DMatrix +casadi_transpose__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_transpose__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_transpose__2" c_casadi_transpose__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_transpose__2 + :: IMatrix -> IO IMatrix +casadi_transpose__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_transpose__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_transpose__3" c_casadi_transpose__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_transpose__3 + :: MX -> IO MX +casadi_transpose__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_transpose__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_transpose__4" c_casadi_transpose__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_transpose__4 + :: Sparsity -> IO Sparsity +casadi_transpose__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_transpose__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triangle__0" c_casadi_triangle__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_triangle__0 + :: SX -> IO SX +casadi_triangle__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triangle__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triangle__1" c_casadi_triangle__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_triangle__1 + :: DMatrix -> IO DMatrix +casadi_triangle__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triangle__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triangle__2" c_casadi_triangle__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_triangle__2 + :: IMatrix -> IO IMatrix +casadi_triangle__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triangle__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__0" c_casadi_tril__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_tril__0 + :: SX -> IO SX +casadi_tril__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__1" c_casadi_tril__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_tril__1 + :: SX -> Bool -> IO SX +casadi_tril__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__2" c_casadi_tril__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_tril__2 + :: DMatrix -> IO DMatrix +casadi_tril__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__3" c_casadi_tril__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_tril__3 + :: DMatrix -> Bool -> IO DMatrix +casadi_tril__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__4" c_casadi_tril__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_tril__4 + :: IMatrix -> IO IMatrix +casadi_tril__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__5" c_casadi_tril__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_tril__5 + :: IMatrix -> Bool -> IO IMatrix +casadi_tril__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__6" c_casadi_tril__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_tril__6 + :: MX -> IO MX +casadi_tril__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__7" c_casadi_tril__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_tril__7 + :: MX -> Bool -> IO MX +casadi_tril__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__8" c_casadi_tril__8 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_tril__8 + :: Sparsity -> IO Sparsity +casadi_tril__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril__9" c_casadi_tril__9 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi_tril__9 + :: Sparsity -> Bool -> IO Sparsity +casadi_tril__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril2symm__0" c_casadi_tril2symm__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_tril2symm__0 + :: SX -> IO SX +casadi_tril2symm__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril2symm__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril2symm__1" c_casadi_tril2symm__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_tril2symm__1 + :: DMatrix -> IO DMatrix +casadi_tril2symm__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril2symm__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril2symm__2" c_casadi_tril2symm__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_tril2symm__2 + :: IMatrix -> IO IMatrix +casadi_tril2symm__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril2symm__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_tril2symm__3" c_casadi_tril2symm__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_tril2symm__3 + :: MX -> IO MX +casadi_tril2symm__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_tril2symm__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__0" c_casadi_triu__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_triu__0 + :: SX -> IO SX +casadi_triu__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__1" c_casadi_triu__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr SX') +casadi_triu__1 + :: SX -> Bool -> IO SX +casadi_triu__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__2" c_casadi_triu__2 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_triu__2 + :: DMatrix -> IO DMatrix +casadi_triu__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__3" c_casadi_triu__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix') +casadi_triu__3 + :: DMatrix -> Bool -> IO DMatrix +casadi_triu__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__4" c_casadi_triu__4 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_triu__4 + :: IMatrix -> IO IMatrix +casadi_triu__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__5" c_casadi_triu__5 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix') +casadi_triu__5 + :: IMatrix -> Bool -> IO IMatrix +casadi_triu__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__6" c_casadi_triu__6 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_triu__6 + :: MX -> IO MX +casadi_triu__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__7" c_casadi_triu__7 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr MX') +casadi_triu__7 + :: MX -> Bool -> IO MX +casadi_triu__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__8" c_casadi_triu__8 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_triu__8 + :: Sparsity -> IO Sparsity +casadi_triu__8 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__8 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu__9" c_casadi_triu__9 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity') +casadi_triu__9 + :: Sparsity -> Bool -> IO Sparsity +casadi_triu__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu2symm__0" c_casadi_triu2symm__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_triu2symm__0 + :: SX -> IO SX +casadi_triu2symm__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu2symm__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu2symm__1" c_casadi_triu2symm__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_triu2symm__1 + :: DMatrix -> IO DMatrix +casadi_triu2symm__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu2symm__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu2symm__2" c_casadi_triu2symm__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_triu2symm__2 + :: IMatrix -> IO IMatrix +casadi_triu2symm__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu2symm__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_triu2symm__3" c_casadi_triu2symm__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_triu2symm__3 + :: MX -> IO MX +casadi_triu2symm__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_triu2symm__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_unite__0" c_casadi_unite__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX') +casadi_unite__0 + :: SX -> SX -> IO SX +casadi_unite__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_unite__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_unite__1" c_casadi_unite__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_unite__1 + :: DMatrix -> DMatrix -> IO DMatrix +casadi_unite__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_unite__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_unite__2" c_casadi_unite__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_unite__2 + :: IMatrix -> IMatrix -> IO IMatrix +casadi_unite__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_unite__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_unite__3" c_casadi_unite__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX') +casadi_unite__3 + :: MX -> MX -> IO MX +casadi_unite__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_unite__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vec__0" c_casadi_vec__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_vec__0 + :: SX -> IO SX +casadi_vec__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vec__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vec__1" c_casadi_vec__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_vec__1 + :: DMatrix -> IO DMatrix +casadi_vec__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vec__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vec__2" c_casadi_vec__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_vec__2 + :: IMatrix -> IO IMatrix +casadi_vec__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vec__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vec__3" c_casadi_vec__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_vec__3 + :: MX -> IO MX +casadi_vec__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vec__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vec__4" c_casadi_vec__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_vec__4 + :: Sparsity -> IO Sparsity +casadi_vec__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vec__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vecNZ__0" c_casadi_vecNZ__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX') +casadi_vecNZ__0 + :: SX -> IO SX +casadi_vecNZ__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vecNZ__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vecNZ__1" c_casadi_vecNZ__1 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix') +casadi_vecNZ__1 + :: DMatrix -> IO DMatrix +casadi_vecNZ__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vecNZ__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vecNZ__2" c_casadi_vecNZ__2 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix') +casadi_vecNZ__2 + :: IMatrix -> IO IMatrix +casadi_vecNZ__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vecNZ__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vecNZ__3" c_casadi_vecNZ__3 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX') +casadi_vecNZ__3 + :: MX -> IO MX +casadi_vecNZ__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vecNZ__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vecNZ__4" c_casadi_vecNZ__4 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity') +casadi_vecNZ__4 + :: Sparsity -> IO Sparsity +casadi_vecNZ__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vecNZ__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_veccat__0" c_casadi_veccat__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') +casadi_veccat__0 + :: Vector SX -> IO SX +casadi_veccat__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_veccat__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_veccat__1" c_casadi_veccat__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') +casadi_veccat__1 + :: Vector DMatrix -> IO DMatrix +casadi_veccat__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_veccat__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_veccat__2" c_casadi_veccat__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') +casadi_veccat__2 + :: Vector IMatrix -> IO IMatrix +casadi_veccat__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_veccat__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_veccat__3" c_casadi_veccat__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi_veccat__3 + :: Vector MX -> IO MX +casadi_veccat__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_veccat__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_veccat__4" c_casadi_veccat__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') +casadi_veccat__4 + :: Vector Sparsity -> IO Sparsity +casadi_veccat__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_veccat__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertcat__0" c_casadi_vertcat__0 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX') +casadi_vertcat__0 + :: Vector SX -> IO SX +casadi_vertcat__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertcat__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertcat__1" c_casadi_vertcat__1 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix') +casadi_vertcat__1 + :: Vector DMatrix -> IO DMatrix +casadi_vertcat__1 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertcat__1 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertcat__2" c_casadi_vertcat__2 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix') +casadi_vertcat__2 + :: Vector IMatrix -> IO IMatrix +casadi_vertcat__2 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertcat__2 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertcat__3" c_casadi_vertcat__3 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX') +casadi_vertcat__3 + :: Vector MX -> IO MX +casadi_vertcat__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertcat__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertcat__4" c_casadi_vertcat__4 + :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity') +casadi_vertcat__4 + :: Vector Sparsity -> IO Sparsity +casadi_vertcat__4 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertcat__4 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__0" c_casadi_vertsplit__0 + :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX'))) +casadi_vertsplit__0 + :: SX -> IO (Vector SX) +casadi_vertsplit__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__1" c_casadi_vertsplit__1 + :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX'))) +casadi_vertsplit__1 + :: SX -> Int -> IO (Vector SX) +casadi_vertsplit__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__2" c_casadi_vertsplit__2 + :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX'))) +casadi_vertsplit__2 + :: SX -> Vector Int -> IO (Vector SX) +casadi_vertsplit__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__3" c_casadi_vertsplit__3 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_vertsplit__3 + :: DMatrix -> IO (Vector DMatrix) +casadi_vertsplit__3 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__3 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__4" c_casadi_vertsplit__4 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_vertsplit__4 + :: DMatrix -> Int -> IO (Vector DMatrix) +casadi_vertsplit__4 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__4 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__5" c_casadi_vertsplit__5 + :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix'))) +casadi_vertsplit__5 + :: DMatrix -> Vector Int -> IO (Vector DMatrix) +casadi_vertsplit__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__6" c_casadi_vertsplit__6 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_vertsplit__6 + :: IMatrix -> IO (Vector IMatrix) +casadi_vertsplit__6 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__6 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__7" c_casadi_vertsplit__7 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_vertsplit__7 + :: IMatrix -> Int -> IO (Vector IMatrix) +casadi_vertsplit__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__8" c_casadi_vertsplit__8 + :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix'))) +casadi_vertsplit__8 + :: IMatrix -> Vector Int -> IO (Vector IMatrix) +casadi_vertsplit__8 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__8 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__9" c_casadi_vertsplit__9 + :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) +casadi_vertsplit__9 + :: MX -> IO (Vector MX) +casadi_vertsplit__9 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__9 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__10" c_casadi_vertsplit__10 + :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) +casadi_vertsplit__10 + :: MX -> Int -> IO (Vector MX) +casadi_vertsplit__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__11" c_casadi_vertsplit__11 + :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX'))) +casadi_vertsplit__11 + :: MX -> Vector Int -> IO (Vector MX) +casadi_vertsplit__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__12" c_casadi_vertsplit__12 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_vertsplit__12 + :: Sparsity -> IO (Vector Sparsity) +casadi_vertsplit__12 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__12 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__13" c_casadi_vertsplit__13 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_vertsplit__13 + :: Sparsity -> Int -> IO (Vector Sparsity) +casadi_vertsplit__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "casadi_vertsplit__14" c_casadi_vertsplit__14 + :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity'))) +casadi_vertsplit__14 + :: Sparsity -> Vector Int -> IO (Vector Sparsity) +casadi_vertsplit__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_casadi_vertsplit__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__0" c_cleIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +cleIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__1" c_cleIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +cleIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__2" c_cleIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +cleIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__3" c_cleIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +cleIn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__4" c_cleIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +cleIn__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__5" c_cleIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +cleIn__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__6" c_cleIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +cleIn__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__7" c_cleIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +cleIn__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__8" c_cleIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +cleIn__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__11" c_cleIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +cleIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__12" c_cleIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +cleIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleIn__13" c_cleIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +cleIn__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +cleIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleOut__0" c_cleOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +cleOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +cleOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleOut__1" c_cleOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +cleOut__1 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +cleOut__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleOut__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleOut__2" c_cleOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +cleOut__2 + :: String -> MX -> IO (M.Map String MX, Vector String) +cleOut__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleOut__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "cleOut__5" c_cleOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +cleOut__5 + :: String -> SX -> IO (M.Map String SX, Vector String) +cleOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_cleOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "collocationInterpolators" c_collocationInterpolators + :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> Ptr (StdVec (Ptr (StdVec CDouble))) -> Ptr (StdVec CDouble) -> IO () +collocationInterpolators + :: Vector Double -> Vector (Vector Double) -> Vector Double -> IO () +collocationInterpolators x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_collocationInterpolators errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "collocationPoints__0" c_collocationPoints__0 + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec CDouble)) +collocationPoints__0 + :: Int -> IO (Vector Double) +collocationPoints__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_collocationPoints__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "collocationPoints__1" c_collocationPoints__1 + :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO (Ptr (StdVec CDouble)) +collocationPoints__1 + :: Int -> String -> IO (Vector Double) +collocationPoints__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_collocationPoints__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "complement" c_complement + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) +complement + :: Vector Int -> Int -> IO (Vector Int) +complement x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_complement errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__0" c_controldaeIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__1" c_controldaeIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__2" c_controldaeIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__3" c_controldaeIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__4" c_controldaeIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__5" c_controldaeIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__6" c_controldaeIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__7" c_controldaeIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__8" c_controldaeIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__9" c_controldaeIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__10" c_controldaeIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__11" c_controldaeIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__12" c_controldaeIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__13" c_controldaeIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__14" c_controldaeIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__15" c_controldaeIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__15 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controldaeIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__16" c_controldaeIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__16 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controldaeIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__17" c_controldaeIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__17 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__18" c_controldaeIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__18 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__19" c_controldaeIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__19 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__20" c_controldaeIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__21" c_controldaeIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__22" c_controldaeIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__22 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__23" c_controldaeIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__23 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__24" c_controldaeIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__25" c_controldaeIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__26" c_controldaeIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__27" c_controldaeIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__28" c_controldaeIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__29" c_controldaeIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__30" c_controldaeIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__30 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__31" c_controldaeIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__31 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__32" c_controldaeIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__32 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controldaeIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__33" c_controldaeIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__33 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controldaeIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__34" c_controldaeIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__34 + :: String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__34 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__34 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__35" c_controldaeIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__35 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__35 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__35 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__36" c_controldaeIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__36 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__36 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__36 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__37" c_controldaeIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__37 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__37 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__37 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__38" c_controldaeIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__38 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__38 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__39" c_controldaeIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__39 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__39 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__40" c_controldaeIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__40 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__40 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__41" c_controldaeIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__41 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__42" c_controldaeIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__42 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__43" c_controldaeIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__43 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__44" c_controldaeIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__44 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__45" c_controldaeIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__45 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__46" c_controldaeIn__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__46 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__47" c_controldaeIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__47 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__48" c_controldaeIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__48 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__49" c_controldaeIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__49 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controldaeIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__50" c_controldaeIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__50 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controldaeIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__53" c_controldaeIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__53 + :: String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__53 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__53 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__54" c_controldaeIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__54 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__54 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__54 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__55" c_controldaeIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__55 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__55 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__55 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__56" c_controldaeIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__56 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__56 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__56 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__57" c_controldaeIn__57 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__57 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__57 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__58" c_controldaeIn__58 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__58 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__58 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__59" c_controldaeIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__59 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__59 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__60" c_controldaeIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__60 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__61" c_controldaeIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__61 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__62" c_controldaeIn__62 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__62 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__63" c_controldaeIn__63 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__63 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__64" c_controldaeIn__64 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__64 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__65" c_controldaeIn__65 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__65 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__66" c_controldaeIn__66 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__66 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__67" c_controldaeIn__67 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__67 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__68" c_controldaeIn__68 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__68 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controldaeIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controldaeIn__69" c_controldaeIn__69 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controldaeIn__69 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controldaeIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_controldaeIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__0" c_controlsimulatorIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controlsimulatorIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__1" c_controlsimulatorIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controlsimulatorIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__2" c_controlsimulatorIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controlsimulatorIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__3" c_controlsimulatorIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +controlsimulatorIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__4" c_controlsimulatorIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +controlsimulatorIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__5" c_controlsimulatorIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__5 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controlsimulatorIn__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__6" c_controlsimulatorIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__6 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controlsimulatorIn__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__7" c_controlsimulatorIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__7 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controlsimulatorIn__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__8" c_controlsimulatorIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__8 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +controlsimulatorIn__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__9" c_controlsimulatorIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__9 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +controlsimulatorIn__9 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__10" c_controlsimulatorIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__10 + :: String -> MX -> IO (M.Map String MX, Vector String) +controlsimulatorIn__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__11" c_controlsimulatorIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__11 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +controlsimulatorIn__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__12" c_controlsimulatorIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__12 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controlsimulatorIn__12 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__12 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__13" c_controlsimulatorIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__13 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +controlsimulatorIn__13 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__13 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__14" c_controlsimulatorIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__14 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +controlsimulatorIn__14 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__17" c_controlsimulatorIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__17 + :: String -> SX -> IO (M.Map String SX, Vector String) +controlsimulatorIn__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__18" c_controlsimulatorIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__18 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +controlsimulatorIn__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__19" c_controlsimulatorIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__19 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controlsimulatorIn__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__20" c_controlsimulatorIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__20 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +controlsimulatorIn__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "controlsimulatorIn__21" c_controlsimulatorIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +controlsimulatorIn__21 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +controlsimulatorIn__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_controlsimulatorIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__0" c_daeIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +daeIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__1" c_daeIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +daeIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__2" c_daeIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +daeIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__3" c_daeIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +daeIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__4" c_daeIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +daeIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__5" c_daeIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +daeIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__6" c_daeIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +daeIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__7" c_daeIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__7 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +daeIn__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__8" c_daeIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__8 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +daeIn__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__9" c_daeIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__9 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +daeIn__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__10" c_daeIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__10 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +daeIn__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__11" c_daeIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__11 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +daeIn__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__12" c_daeIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__12 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +daeIn__12 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__13" c_daeIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +daeIn__13 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__14" c_daeIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__14 + :: String -> MX -> IO (M.Map String MX, Vector String) +daeIn__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__15" c_daeIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__15 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +daeIn__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__16" c_daeIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__16 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +daeIn__16 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__16 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__17" c_daeIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__17 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +daeIn__17 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__17 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__18" c_daeIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__18 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +daeIn__18 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__19" c_daeIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__19 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +daeIn__19 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__20" c_daeIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__20 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +daeIn__20 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__23" c_daeIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__23 + :: String -> SX -> IO (M.Map String SX, Vector String) +daeIn__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__24" c_daeIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__24 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +daeIn__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__25" c_daeIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__25 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +daeIn__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__26" c_daeIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__26 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +daeIn__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__27" c_daeIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__27 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +daeIn__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__28" c_daeIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__28 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +daeIn__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeIn__29" c_daeIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeIn__29 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +daeIn__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__0" c_daeOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +daeOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__1" c_daeOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +daeOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__2" c_daeOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +daeOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__3" c_daeOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +daeOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__4" c_daeOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +daeOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__5" c_daeOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__5 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +daeOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__6" c_daeOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__6 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +daeOut__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__7" c_daeOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__7 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +daeOut__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__8" c_daeOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__8 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +daeOut__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__9" c_daeOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__9 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +daeOut__9 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__10" c_daeOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__10 + :: String -> MX -> IO (M.Map String MX, Vector String) +daeOut__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__11" c_daeOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__11 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +daeOut__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__12" c_daeOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__12 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +daeOut__12 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__12 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__13" c_daeOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__13 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +daeOut__13 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__13 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__14" c_daeOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__14 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +daeOut__14 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__17" c_daeOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__17 + :: String -> SX -> IO (M.Map String SX, Vector String) +daeOut__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__18" c_daeOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__18 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +daeOut__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__19" c_daeOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__19 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +daeOut__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__20" c_daeOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__20 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +daeOut__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "daeOut__21" c_daeOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +daeOut__21 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +daeOut__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_daeOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__0" c_dleIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +dleIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__1" c_dleIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +dleIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__2" c_dleIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +dleIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__3" c_dleIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +dleIn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__4" c_dleIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +dleIn__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__5" c_dleIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +dleIn__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__6" c_dleIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +dleIn__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__7" c_dleIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +dleIn__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__8" c_dleIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +dleIn__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__11" c_dleIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +dleIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__12" c_dleIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +dleIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleIn__13" c_dleIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dleIn__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +dleIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleOut__0" c_dleOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dleOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +dleOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleOut__1" c_dleOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dleOut__1 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +dleOut__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleOut__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleOut__2" c_dleOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dleOut__2 + :: String -> MX -> IO (M.Map String MX, Vector String) +dleOut__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleOut__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dleOut__5" c_dleOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dleOut__5 + :: String -> SX -> IO (M.Map String SX, Vector String) +dleOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dleOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__0" c_dpleIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +dpleIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__1" c_dpleIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +dpleIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__2" c_dpleIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +dpleIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__3" c_dpleIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +dpleIn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__4" c_dpleIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +dpleIn__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__5" c_dpleIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +dpleIn__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__6" c_dpleIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +dpleIn__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__7" c_dpleIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +dpleIn__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__8" c_dpleIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +dpleIn__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__11" c_dpleIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +dpleIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__12" c_dpleIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +dpleIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleIn__13" c_dpleIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dpleIn__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +dpleIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleOut__0" c_dpleOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +dpleOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +dpleOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleOut__1" c_dpleOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +dpleOut__1 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +dpleOut__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleOut__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleOut__2" c_dpleOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +dpleOut__2 + :: String -> MX -> IO (M.Map String MX, Vector String) +dpleOut__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleOut__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "dpleOut__5" c_dpleOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +dpleOut__5 + :: String -> SX -> IO (M.Map String SX, Vector String) +dpleOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_dpleOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "getSchemeEntryDoc" c_getSchemeEntryDoc + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString) +getSchemeEntryDoc + :: InputOutputScheme -> Int -> IO String +getSchemeEntryDoc x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_getSchemeEntryDoc errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "getSchemeEntryEnum" c_getSchemeEntryEnum + :: Ptr (Ptr StdString) -> CInt -> Ptr StdString -> IO CInt +getSchemeEntryEnum + :: InputOutputScheme -> String -> IO Int +getSchemeEntryEnum x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_getSchemeEntryEnum errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "getSchemeEntryEnumName" c_getSchemeEntryEnumName + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString) +getSchemeEntryEnumName + :: InputOutputScheme -> Int -> IO String +getSchemeEntryEnumName x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_getSchemeEntryEnumName errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "getSchemeEntryName" c_getSchemeEntryName + :: Ptr (Ptr StdString) -> CInt -> CInt -> IO (Ptr StdString) +getSchemeEntryName + :: InputOutputScheme -> Int -> IO String +getSchemeEntryName x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_getSchemeEntryName errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "getSchemeEntryNames" c_getSchemeEntryNames + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString) +getSchemeEntryNames + :: InputOutputScheme -> IO String +getSchemeEntryNames x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_getSchemeEntryNames errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "getSchemeName" c_getSchemeName + :: Ptr (Ptr StdString) -> CInt -> IO (Ptr StdString) +getSchemeName + :: InputOutputScheme -> IO String +getSchemeName x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_getSchemeName errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "getSchemeSize" c_getSchemeSize + :: Ptr (Ptr StdString) -> CInt -> IO CInt +getSchemeSize + :: InputOutputScheme -> IO Int +getSchemeSize x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_getSchemeSize errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__0" c_gradFIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +gradFIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__1" c_gradFIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +gradFIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__2" c_gradFIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +gradFIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__3" c_gradFIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +gradFIn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__4" c_gradFIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +gradFIn__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__5" c_gradFIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +gradFIn__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__6" c_gradFIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +gradFIn__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__7" c_gradFIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +gradFIn__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__8" c_gradFIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +gradFIn__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__11" c_gradFIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +gradFIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__12" c_gradFIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +gradFIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFIn__13" c_gradFIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFIn__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +gradFIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__0" c_gradFOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +gradFOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__1" c_gradFOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +gradFOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__2" c_gradFOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +gradFOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__3" c_gradFOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +gradFOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__4" c_gradFOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +gradFOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__5" c_gradFOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__5 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +gradFOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__6" c_gradFOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__6 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +gradFOut__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__7" c_gradFOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__7 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +gradFOut__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__8" c_gradFOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__8 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +gradFOut__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__9" c_gradFOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__9 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +gradFOut__9 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__10" c_gradFOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__10 + :: String -> MX -> IO (M.Map String MX, Vector String) +gradFOut__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__11" c_gradFOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__11 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +gradFOut__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__12" c_gradFOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__12 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +gradFOut__12 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__12 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__13" c_gradFOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__13 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +gradFOut__13 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__13 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__14" c_gradFOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__14 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +gradFOut__14 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__17" c_gradFOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__17 + :: String -> SX -> IO (M.Map String SX, Vector String) +gradFOut__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__18" c_gradFOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__18 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +gradFOut__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__19" c_gradFOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__19 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +gradFOut__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__20" c_gradFOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__20 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +gradFOut__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "gradFOut__21" c_gradFOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +gradFOut__21 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +gradFOut__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_gradFOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__0" c_hessLagIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__1" c_hessLagIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hessLagIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__2" c_hessLagIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__3" c_hessLagIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hessLagIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__4" c_hessLagIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__5" c_hessLagIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hessLagIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__6" c_hessLagIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__7" c_hessLagIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__7 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagIn__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__8" c_hessLagIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__8 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hessLagIn__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__9" c_hessLagIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__9 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagIn__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__10" c_hessLagIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__10 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hessLagIn__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__11" c_hessLagIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__11 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagIn__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__12" c_hessLagIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__12 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hessLagIn__12 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__13" c_hessLagIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagIn__13 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__14" c_hessLagIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__14 + :: String -> MX -> IO (M.Map String MX, Vector String) +hessLagIn__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__15" c_hessLagIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__15 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +hessLagIn__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__16" c_hessLagIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__16 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hessLagIn__16 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__16 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__17" c_hessLagIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__17 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +hessLagIn__17 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__17 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__18" c_hessLagIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__18 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hessLagIn__18 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__19" c_hessLagIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__19 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +hessLagIn__19 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__20" c_hessLagIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__20 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hessLagIn__20 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__23" c_hessLagIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__23 + :: String -> SX -> IO (M.Map String SX, Vector String) +hessLagIn__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__24" c_hessLagIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__24 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +hessLagIn__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__25" c_hessLagIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__25 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hessLagIn__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__26" c_hessLagIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__26 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +hessLagIn__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__27" c_hessLagIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__27 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hessLagIn__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__28" c_hessLagIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__28 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +hessLagIn__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagIn__29" c_hessLagIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagIn__29 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hessLagIn__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__0" c_hessLagOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__1" c_hessLagOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hessLagOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__2" c_hessLagOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__3" c_hessLagOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hessLagOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__4" c_hessLagOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__5" c_hessLagOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hessLagOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__6" c_hessLagOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__7" c_hessLagOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hessLagOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__8" c_hessLagOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hessLagOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__9" c_hessLagOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__9 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagOut__9 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__9 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__10" c_hessLagOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__10 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hessLagOut__10 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__10 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__11" c_hessLagOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__11 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagOut__11 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__11 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__12" c_hessLagOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__12 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hessLagOut__12 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__12 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__13" c_hessLagOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagOut__13 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__14" c_hessLagOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__14 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hessLagOut__14 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__15" c_hessLagOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__15 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagOut__15 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__16" c_hessLagOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__16 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hessLagOut__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__17" c_hessLagOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hessLagOut__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__18" c_hessLagOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__18 + :: String -> MX -> IO (M.Map String MX, Vector String) +hessLagOut__18 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__18 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__19" c_hessLagOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__19 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +hessLagOut__19 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__19 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__20" c_hessLagOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__20 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hessLagOut__20 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__20 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__21" c_hessLagOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__21 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +hessLagOut__21 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__21 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__22" c_hessLagOut__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__22 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hessLagOut__22 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__22 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__23" c_hessLagOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__23 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +hessLagOut__23 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__24" c_hessLagOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__24 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hessLagOut__24 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__25" c_hessLagOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__25 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +hessLagOut__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__26" c_hessLagOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__26 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hessLagOut__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__29" c_hessLagOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__29 + :: String -> SX -> IO (M.Map String SX, Vector String) +hessLagOut__29 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__29 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__30" c_hessLagOut__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__30 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +hessLagOut__30 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__30 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__31" c_hessLagOut__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__31 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hessLagOut__31 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__31 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__32" c_hessLagOut__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__32 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +hessLagOut__32 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__32 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__33" c_hessLagOut__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__33 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hessLagOut__33 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__33 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__34" c_hessLagOut__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__34 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +hessLagOut__34 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__35" c_hessLagOut__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__35 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hessLagOut__35 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__36" c_hessLagOut__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__36 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +hessLagOut__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hessLagOut__37" c_hessLagOut__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hessLagOut__37 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hessLagOut__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_hessLagOut__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__0" c_hnlpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hnlpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__1" c_hnlpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hnlpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__2" c_hnlpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hnlpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__3" c_hnlpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +hnlpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__4" c_hnlpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +hnlpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__5" c_hnlpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__5 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hnlpIn__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__6" c_hnlpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__6 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hnlpIn__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__7" c_hnlpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__7 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hnlpIn__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__8" c_hnlpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__8 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +hnlpIn__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__9" c_hnlpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__9 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +hnlpIn__9 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__10" c_hnlpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__10 + :: String -> MX -> IO (M.Map String MX, Vector String) +hnlpIn__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__11" c_hnlpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__11 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +hnlpIn__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__12" c_hnlpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__12 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hnlpIn__12 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__12 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__13" c_hnlpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__13 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +hnlpIn__13 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__13 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__14" c_hnlpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__14 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +hnlpIn__14 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__17" c_hnlpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__17 + :: String -> SX -> IO (M.Map String SX, Vector String) +hnlpIn__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__18" c_hnlpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__18 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +hnlpIn__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__19" c_hnlpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__19 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hnlpIn__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__20" c_hnlpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__20 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +hnlpIn__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "hnlpIn__21" c_hnlpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +hnlpIn__21 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +hnlpIn__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_hnlpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__0" c_integratorIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__1" c_integratorIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__2" c_integratorIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__3" c_integratorIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__4" c_integratorIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__5" c_integratorIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__6" c_integratorIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__7" c_integratorIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__8" c_integratorIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__9" c_integratorIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__10" c_integratorIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__11" c_integratorIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__11 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__12" c_integratorIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__12 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__13" c_integratorIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__13 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__14" c_integratorIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__14 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorIn__14 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__14 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__15" c_integratorIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__15 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorIn__15 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__16" c_integratorIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__16 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorIn__16 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__17" c_integratorIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorIn__17 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__18" c_integratorIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__19" c_integratorIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__20" c_integratorIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__21" c_integratorIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__22" c_integratorIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__22 + :: String -> MX -> IO (M.Map String MX, Vector String) +integratorIn__22 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__22 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__23" c_integratorIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__23 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorIn__23 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__23 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__24" c_integratorIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__24 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorIn__24 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__24 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__25" c_integratorIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__25 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorIn__25 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__25 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__26" c_integratorIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__26 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorIn__26 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__27" c_integratorIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__27 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorIn__27 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__28" c_integratorIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__28 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorIn__28 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__29" c_integratorIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__29 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__30" c_integratorIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__30 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__31" c_integratorIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__32" c_integratorIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__35" c_integratorIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__35 + :: String -> SX -> IO (M.Map String SX, Vector String) +integratorIn__35 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__35 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__36" c_integratorIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__36 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorIn__36 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__36 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__37" c_integratorIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__37 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorIn__37 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__37 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__38" c_integratorIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__38 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorIn__38 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__38 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__39" c_integratorIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__39 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorIn__39 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__40" c_integratorIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__40 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorIn__40 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__41" c_integratorIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__41 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorIn__41 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__42" c_integratorIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__42 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__43" c_integratorIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__43 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__44" c_integratorIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__44 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorIn__45" c_integratorIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorIn__45 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__0" c_integratorOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__1" c_integratorOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__2" c_integratorOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__3" c_integratorOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__4" c_integratorOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__5" c_integratorOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__6" c_integratorOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__7" c_integratorOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__8" c_integratorOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__9" c_integratorOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +integratorOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__10" c_integratorOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +integratorOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__11" c_integratorOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__11 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorOut__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__12" c_integratorOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__12 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorOut__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__13" c_integratorOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__13 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorOut__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__14" c_integratorOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__14 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorOut__14 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__14 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__15" c_integratorOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__15 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorOut__15 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__16" c_integratorOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__16 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorOut__16 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__17" c_integratorOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorOut__17 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__18" c_integratorOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorOut__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__19" c_integratorOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorOut__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__20" c_integratorOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +integratorOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__21" c_integratorOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +integratorOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__22" c_integratorOut__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__22 + :: String -> MX -> IO (M.Map String MX, Vector String) +integratorOut__22 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__22 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__23" c_integratorOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__23 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorOut__23 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__23 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__24" c_integratorOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__24 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorOut__24 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__24 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__25" c_integratorOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__25 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorOut__25 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__25 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__26" c_integratorOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__26 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorOut__26 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__27" c_integratorOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__27 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorOut__27 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__28" c_integratorOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__28 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorOut__28 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__29" c_integratorOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__29 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorOut__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__30" c_integratorOut__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__30 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorOut__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__31" c_integratorOut__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +integratorOut__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__32" c_integratorOut__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +integratorOut__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__35" c_integratorOut__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__35 + :: String -> SX -> IO (M.Map String SX, Vector String) +integratorOut__35 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__35 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__36" c_integratorOut__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__36 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorOut__36 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__36 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__37" c_integratorOut__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__37 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorOut__37 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__37 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__38" c_integratorOut__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__38 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorOut__38 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__38 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__39" c_integratorOut__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__39 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorOut__39 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__39 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__40" c_integratorOut__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__40 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorOut__40 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__41" c_integratorOut__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__41 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorOut__41 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__42" c_integratorOut__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__42 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorOut__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__43" c_integratorOut__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__43 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorOut__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__44" c_integratorOut__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__44 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +integratorOut__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "integratorOut__45" c_integratorOut__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +integratorOut__45 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +integratorOut__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_integratorOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__0" c_jacGIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +jacGIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__1" c_jacGIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +jacGIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__2" c_jacGIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +jacGIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__3" c_jacGIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +jacGIn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__4" c_jacGIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +jacGIn__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__5" c_jacGIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +jacGIn__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__6" c_jacGIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +jacGIn__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__7" c_jacGIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +jacGIn__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__8" c_jacGIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +jacGIn__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__11" c_jacGIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +jacGIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__12" c_jacGIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +jacGIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGIn__13" c_jacGIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGIn__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +jacGIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__0" c_jacGOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +jacGOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__1" c_jacGOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +jacGOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__2" c_jacGOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +jacGOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__3" c_jacGOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +jacGOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__4" c_jacGOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +jacGOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__5" c_jacGOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__5 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +jacGOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__6" c_jacGOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__6 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +jacGOut__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__7" c_jacGOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__7 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +jacGOut__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__8" c_jacGOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__8 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +jacGOut__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__9" c_jacGOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__9 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +jacGOut__9 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__10" c_jacGOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__10 + :: String -> MX -> IO (M.Map String MX, Vector String) +jacGOut__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__11" c_jacGOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__11 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +jacGOut__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__12" c_jacGOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__12 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +jacGOut__12 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__12 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__13" c_jacGOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__13 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +jacGOut__13 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__13 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__14" c_jacGOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__14 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +jacGOut__14 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__17" c_jacGOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__17 + :: String -> SX -> IO (M.Map String SX, Vector String) +jacGOut__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__18" c_jacGOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__18 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +jacGOut__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__19" c_jacGOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__19 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +jacGOut__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__20" c_jacGOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__20 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +jacGOut__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "jacGOut__21" c_jacGOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +jacGOut__21 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +jacGOut__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_jacGOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__0" c_linsolIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +linsolIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__1" c_linsolIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +linsolIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__2" c_linsolIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +linsolIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__3" c_linsolIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +linsolIn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__4" c_linsolIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +linsolIn__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__5" c_linsolIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +linsolIn__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__6" c_linsolIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +linsolIn__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__7" c_linsolIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +linsolIn__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__8" c_linsolIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +linsolIn__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__11" c_linsolIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +linsolIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__12" c_linsolIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +linsolIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolIn__13" c_linsolIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +linsolIn__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +linsolIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolOut__0" c_linsolOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +linsolOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +linsolOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolOut__1" c_linsolOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +linsolOut__1 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +linsolOut__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolOut__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolOut__2" c_linsolOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +linsolOut__2 + :: String -> MX -> IO (M.Map String MX, Vector String) +linsolOut__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolOut__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "linsolOut__5" c_linsolOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +linsolOut__5 + :: String -> SX -> IO (M.Map String SX, Vector String) +linsolOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_linsolOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lookupvector" c_lookupvector + :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> IO (Ptr (StdVec CInt)) +lookupvector + :: Vector Int -> Int -> IO (Vector Int) +lookupvector x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lookupvector errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__0" c_lpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__1" c_lpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__2" c_lpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__3" c_lpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__4" c_lpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__5" c_lpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__6" c_lpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__7" c_lpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__8" c_lpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__9" c_lpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__10" c_lpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__11" c_lpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__11 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__12" c_lpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__12 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__13" c_lpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__13 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__14" c_lpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__14 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpIn__14 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__14 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__15" c_lpIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__15 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpIn__15 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__16" c_lpIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__16 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpIn__16 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__17" c_lpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__18" c_lpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__19" c_lpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__20" c_lpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__21" c_lpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__22" c_lpIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__22 + :: String -> MX -> IO (M.Map String MX, Vector String) +lpIn__22 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__22 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__23" c_lpIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__23 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +lpIn__23 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__23 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__24" c_lpIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__24 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpIn__24 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__24 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__25" c_lpIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__25 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lpIn__25 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__25 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__26" c_lpIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__26 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpIn__26 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__27" c_lpIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__27 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lpIn__27 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__28" c_lpIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__28 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__29" c_lpIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__29 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__30" c_lpIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__30 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__31" c_lpIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__32" c_lpIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__35" c_lpIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__35 + :: String -> SX -> IO (M.Map String SX, Vector String) +lpIn__35 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__35 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__36" c_lpIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__36 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +lpIn__36 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__36 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__37" c_lpIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__37 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpIn__37 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__37 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__38" c_lpIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__38 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lpIn__38 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__38 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__39" c_lpIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__39 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpIn__39 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__40" c_lpIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__40 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lpIn__40 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__41" c_lpIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__41 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__42" c_lpIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__42 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__43" c_lpIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__43 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__44" c_lpIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__44 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpIn__45" c_lpIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpIn__45 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__0" c_lpOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__1" c_lpOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__2" c_lpOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__3" c_lpOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__4" c_lpOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__5" c_lpOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lpOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__6" c_lpOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__7" c_lpOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__7 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpOut__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__8" c_lpOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__8 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpOut__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__9" c_lpOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__9 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpOut__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__10" c_lpOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__10 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpOut__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__11" c_lpOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__11 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpOut__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__12" c_lpOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__12 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lpOut__12 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__13" c_lpOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lpOut__13 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__14" c_lpOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__14 + :: String -> MX -> IO (M.Map String MX, Vector String) +lpOut__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__15" c_lpOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__15 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +lpOut__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__16" c_lpOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__16 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpOut__16 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__16 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__17" c_lpOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__17 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lpOut__17 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__17 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__18" c_lpOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__18 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpOut__18 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__19" c_lpOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__19 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lpOut__19 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__20" c_lpOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__20 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__23" c_lpOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__23 + :: String -> SX -> IO (M.Map String SX, Vector String) +lpOut__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__24" c_lpOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__24 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +lpOut__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__25" c_lpOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__25 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpOut__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__26" c_lpOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__26 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lpOut__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__27" c_lpOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__27 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpOut__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__28" c_lpOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__28 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lpOut__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lpOut__29" c_lpOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lpOut__29 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__0" c_lrdleIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdleIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__1" c_lrdleIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lrdleIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__2" c_lrdleIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdleIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__3" c_lrdleIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lrdleIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__4" c_lrdleIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdleIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__5" c_lrdleIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lrdleIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__6" c_lrdleIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdleIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__7" c_lrdleIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__7 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdleIn__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__8" c_lrdleIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__8 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lrdleIn__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__9" c_lrdleIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__9 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdleIn__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__10" c_lrdleIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__10 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lrdleIn__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__11" c_lrdleIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__11 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdleIn__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__12" c_lrdleIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__12 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lrdleIn__12 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__13" c_lrdleIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdleIn__13 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__14" c_lrdleIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__14 + :: String -> MX -> IO (M.Map String MX, Vector String) +lrdleIn__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__15" c_lrdleIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__15 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +lrdleIn__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__16" c_lrdleIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__16 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lrdleIn__16 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__16 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__17" c_lrdleIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__17 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lrdleIn__17 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__17 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__18" c_lrdleIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__18 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lrdleIn__18 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__19" c_lrdleIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__19 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lrdleIn__19 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__20" c_lrdleIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__20 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lrdleIn__20 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__23" c_lrdleIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__23 + :: String -> SX -> IO (M.Map String SX, Vector String) +lrdleIn__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__24" c_lrdleIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__24 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +lrdleIn__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__25" c_lrdleIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__25 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lrdleIn__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__26" c_lrdleIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__26 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lrdleIn__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__27" c_lrdleIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__27 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lrdleIn__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__28" c_lrdleIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__28 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lrdleIn__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleIn__29" c_lrdleIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleIn__29 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lrdleIn__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleOut__0" c_lrdleOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdleOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdleOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleOut__1" c_lrdleOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdleOut__1 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdleOut__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleOut__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleOut__2" c_lrdleOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleOut__2 + :: String -> MX -> IO (M.Map String MX, Vector String) +lrdleOut__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleOut__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdleOut__5" c_lrdleOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdleOut__5 + :: String -> SX -> IO (M.Map String SX, Vector String) +lrdleOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdleOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__0" c_lrdpleIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdpleIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__1" c_lrdpleIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lrdpleIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__2" c_lrdpleIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdpleIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__3" c_lrdpleIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lrdpleIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__4" c_lrdpleIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdpleIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__5" c_lrdpleIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +lrdpleIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__6" c_lrdpleIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdpleIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__7" c_lrdpleIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__7 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdpleIn__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__8" c_lrdpleIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__8 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lrdpleIn__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__9" c_lrdpleIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__9 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdpleIn__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__10" c_lrdpleIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__10 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lrdpleIn__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__11" c_lrdpleIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__11 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdpleIn__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__12" c_lrdpleIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__12 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +lrdpleIn__12 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__13" c_lrdpleIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdpleIn__13 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__14" c_lrdpleIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__14 + :: String -> MX -> IO (M.Map String MX, Vector String) +lrdpleIn__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__15" c_lrdpleIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__15 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +lrdpleIn__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__16" c_lrdpleIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__16 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lrdpleIn__16 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__16 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__17" c_lrdpleIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__17 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lrdpleIn__17 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__17 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__18" c_lrdpleIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__18 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lrdpleIn__18 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__19" c_lrdpleIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__19 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +lrdpleIn__19 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__20" c_lrdpleIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__20 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +lrdpleIn__20 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__23" c_lrdpleIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__23 + :: String -> SX -> IO (M.Map String SX, Vector String) +lrdpleIn__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__24" c_lrdpleIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__24 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +lrdpleIn__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__25" c_lrdpleIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__25 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lrdpleIn__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__26" c_lrdpleIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__26 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lrdpleIn__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__27" c_lrdpleIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__27 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lrdpleIn__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__28" c_lrdpleIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__28 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +lrdpleIn__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleIn__29" c_lrdpleIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleIn__29 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +lrdpleIn__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleOut__0" c_lrdpleOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +lrdpleOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleOut__1" c_lrdpleOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleOut__1 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +lrdpleOut__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleOut__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleOut__2" c_lrdpleOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleOut__2 + :: String -> MX -> IO (M.Map String MX, Vector String) +lrdpleOut__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleOut__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "lrdpleOut__5" c_lrdpleOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +lrdpleOut__5 + :: String -> SX -> IO (M.Map String SX, Vector String) +lrdpleOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_lrdpleOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__0" c_nlpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__1" c_nlpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__2" c_nlpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__3" c_nlpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpIn__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__4" c_nlpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpIn__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__5" c_nlpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpIn__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__6" c_nlpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +nlpIn__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__7" c_nlpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpIn__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__8" c_nlpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpIn__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__11" c_nlpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +nlpIn__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__12" c_nlpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpIn__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpIn__13" c_nlpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpIn__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpIn__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpIn__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__0" c_nlpOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__1" c_nlpOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__2" c_nlpOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__3" c_nlpOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__3 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpOut__3 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__3 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__4" c_nlpOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__4 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpOut__4 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__4 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__5" c_nlpOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__5 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpOut__5 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__5 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__6" c_nlpOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__6 + :: String -> MX -> IO (M.Map String MX, Vector String) +nlpOut__6 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__6 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__7" c_nlpOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__7 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpOut__7 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__7 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__8" c_nlpOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__8 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpOut__8 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__8 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__11" c_nlpOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__11 + :: String -> SX -> IO (M.Map String SX, Vector String) +nlpOut__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__12" c_nlpOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__12 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpOut__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpOut__13" c_nlpOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpOut__13 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpOut__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpOut__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__0" c_nlpSolverIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__1" c_nlpSolverIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__2" c_nlpSolverIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__3" c_nlpSolverIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__4" c_nlpSolverIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__5" c_nlpSolverIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__6" c_nlpSolverIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__7" c_nlpSolverIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__8" c_nlpSolverIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__9" c_nlpSolverIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__10" c_nlpSolverIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__11" c_nlpSolverIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__12" c_nlpSolverIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__13" c_nlpSolverIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__14" c_nlpSolverIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__15" c_nlpSolverIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__15 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__15 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__15 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__16" c_nlpSolverIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__16 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__16 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__16 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__17" c_nlpSolverIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__17 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__17 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__17 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__18" c_nlpSolverIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__18 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__18 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__18 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__19" c_nlpSolverIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__19 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__20" c_nlpSolverIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__20 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__21" c_nlpSolverIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__21 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__22" c_nlpSolverIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__23" c_nlpSolverIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__24" c_nlpSolverIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__25" c_nlpSolverIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__26" c_nlpSolverIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__27" c_nlpSolverIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__28" c_nlpSolverIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__29" c_nlpSolverIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__30" c_nlpSolverIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__30 + :: String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__30 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__30 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__31" c_nlpSolverIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__31 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverIn__31 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__31 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__32" c_nlpSolverIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__32 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__32 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__32 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__33" c_nlpSolverIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__33 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverIn__33 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__33 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__34" c_nlpSolverIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__34 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__34 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__35" c_nlpSolverIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__35 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverIn__35 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__36" c_nlpSolverIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__36 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__36 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__37" c_nlpSolverIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__37 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__38" c_nlpSolverIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__38 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__39" c_nlpSolverIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__39 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__40" c_nlpSolverIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__40 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__41" c_nlpSolverIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__41 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__42" c_nlpSolverIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__42 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__43" c_nlpSolverIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__43 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__44" c_nlpSolverIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__44 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__47" c_nlpSolverIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__47 + :: String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__47 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__47 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__48" c_nlpSolverIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__48 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverIn__48 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__48 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__49" c_nlpSolverIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__49 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__49 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__49 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__50" c_nlpSolverIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__50 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverIn__50 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__50 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__51" c_nlpSolverIn__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__51 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__51 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__52" c_nlpSolverIn__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__52 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverIn__52 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__53" c_nlpSolverIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__53 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__53 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__54" c_nlpSolverIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__54 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__55" c_nlpSolverIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__55 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__56" c_nlpSolverIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__56 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__57" c_nlpSolverIn__57 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__57 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__58" c_nlpSolverIn__58 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__58 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__59" c_nlpSolverIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__59 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__60" c_nlpSolverIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__60 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverIn__61" c_nlpSolverIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverIn__61 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__0" c_nlpSolverOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__1" c_nlpSolverOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__2" c_nlpSolverOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__3" c_nlpSolverOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__4" c_nlpSolverOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__5" c_nlpSolverOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__6" c_nlpSolverOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__7" c_nlpSolverOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__8" c_nlpSolverOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__9" c_nlpSolverOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__10" c_nlpSolverOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +nlpSolverOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__11" c_nlpSolverOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__11 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__12" c_nlpSolverOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__12 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__13" c_nlpSolverOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__13 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__14" c_nlpSolverOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__14 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__14 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__14 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__15" c_nlpSolverOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__15 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__15 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__16" c_nlpSolverOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__16 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__16 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__17" c_nlpSolverOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__17 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__18" c_nlpSolverOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__19" c_nlpSolverOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__20" c_nlpSolverOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__21" c_nlpSolverOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +nlpSolverOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__22" c_nlpSolverOut__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__22 + :: String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverOut__22 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__22 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__23" c_nlpSolverOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__23 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverOut__23 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__23 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__24" c_nlpSolverOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__24 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverOut__24 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__24 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__25" c_nlpSolverOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__25 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverOut__25 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__25 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__26" c_nlpSolverOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__26 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverOut__26 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__27" c_nlpSolverOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__27 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverOut__27 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__28" c_nlpSolverOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__28 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverOut__28 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__29" c_nlpSolverOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__29 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverOut__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__30" c_nlpSolverOut__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__30 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverOut__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__31" c_nlpSolverOut__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +nlpSolverOut__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__32" c_nlpSolverOut__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +nlpSolverOut__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__35" c_nlpSolverOut__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__35 + :: String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverOut__35 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__35 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__36" c_nlpSolverOut__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__36 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverOut__36 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__36 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__37" c_nlpSolverOut__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__37 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverOut__37 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__37 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__38" c_nlpSolverOut__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__38 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverOut__38 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__38 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__39" c_nlpSolverOut__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__39 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverOut__39 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__39 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__40" c_nlpSolverOut__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__40 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverOut__40 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__41" c_nlpSolverOut__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__41 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverOut__41 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__42" c_nlpSolverOut__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__42 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverOut__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__43" c_nlpSolverOut__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__43 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverOut__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__44" c_nlpSolverOut__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__44 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +nlpSolverOut__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "nlpSolverOut__45" c_nlpSolverOut__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +nlpSolverOut__45 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +nlpSolverOut__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_nlpSolverOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__0" c_qcqpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__1" c_qcqpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__2" c_qcqpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__3" c_qcqpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__4" c_qcqpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__5" c_qcqpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__6" c_qcqpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__7" c_qcqpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__8" c_qcqpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__9" c_qcqpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__10" c_qcqpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__11" c_qcqpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__12" c_qcqpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__13" c_qcqpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__14" c_qcqpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__15" c_qcqpIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__15 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__16" c_qcqpIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__16 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__17" c_qcqpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__17 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__18" c_qcqpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__18 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__19" c_qcqpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__19 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__20" c_qcqpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__20 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__21" c_qcqpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__21 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__22" c_qcqpIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__22 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__23" c_qcqpIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__23 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__24" c_qcqpIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__24 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__25" c_qcqpIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__25 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__26" c_qcqpIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__27" c_qcqpIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__28" c_qcqpIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__29" c_qcqpIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__30" c_qcqpIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__30 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__31" c_qcqpIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__31 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__32" c_qcqpIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__32 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__33" c_qcqpIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__33 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__34" c_qcqpIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__34 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__35" c_qcqpIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__35 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__36" c_qcqpIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__36 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__37" c_qcqpIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__37 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__38" c_qcqpIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__38 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__39" c_qcqpIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__39 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__40" c_qcqpIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__40 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__41" c_qcqpIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__41 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__42" c_qcqpIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__42 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__43" c_qcqpIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__43 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__44" c_qcqpIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__44 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__45" c_qcqpIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__45 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__46" c_qcqpIn__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__46 + :: String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__46 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__46 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__47" c_qcqpIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__47 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__47 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__47 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__48" c_qcqpIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__48 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__48 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__48 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__49" c_qcqpIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__49 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__49 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__49 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__50" c_qcqpIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__50 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__50 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__51" c_qcqpIn__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__51 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__51 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__52" c_qcqpIn__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__52 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__52 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__53" c_qcqpIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__53 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__54" c_qcqpIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__54 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__55" c_qcqpIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__55 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__56" c_qcqpIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__56 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__57" c_qcqpIn__57 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__57 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__58" c_qcqpIn__58 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__58 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__59" c_qcqpIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__59 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__60" c_qcqpIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__60 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__61" c_qcqpIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__61 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__62" c_qcqpIn__62 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__62 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__63" c_qcqpIn__63 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__63 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__64" c_qcqpIn__64 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__64 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__65" c_qcqpIn__65 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__65 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__66" c_qcqpIn__66 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__66 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__67" c_qcqpIn__67 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__67 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__68" c_qcqpIn__68 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__68 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__71" c_qcqpIn__71 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__71 + :: String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__71 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__71 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__72" c_qcqpIn__72 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__72 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__72 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__72 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__73" c_qcqpIn__73 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__73 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__73 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__73 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__74" c_qcqpIn__74 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__74 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__74 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__74 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__75" c_qcqpIn__75 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__75 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__75 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__75 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__76" c_qcqpIn__76 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__76 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__76 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__76 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__77" c_qcqpIn__77 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__77 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__77 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__77 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__78" c_qcqpIn__78 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__78 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__78 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__78 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__79" c_qcqpIn__79 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__79 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__79 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__79 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__80" c_qcqpIn__80 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__80 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__80 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__80 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__81" c_qcqpIn__81 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__81 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__81 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__81 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__82" c_qcqpIn__82 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__82 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__82 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__82 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__83" c_qcqpIn__83 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__83 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__83 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__83 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__84" c_qcqpIn__84 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__84 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__84 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__84 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__85" c_qcqpIn__85 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__85 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__85 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__85 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__86" c_qcqpIn__86 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__86 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__86 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__86 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__87" c_qcqpIn__87 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__87 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__87 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__87 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__88" c_qcqpIn__88 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__88 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__88 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__88 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__89" c_qcqpIn__89 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__89 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__89 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__89 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__90" c_qcqpIn__90 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__90 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__90 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__90 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__91" c_qcqpIn__91 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__91 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__91 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__91 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__92" c_qcqpIn__92 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__92 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpIn__92 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__92 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpIn__93" c_qcqpIn__93 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpIn__93 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpIn__93 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpIn__93 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__0" c_qcqpOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__1" c_qcqpOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__2" c_qcqpOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__3" c_qcqpOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__4" c_qcqpOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__5" c_qcqpOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qcqpOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__6" c_qcqpOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qcqpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__7" c_qcqpOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__7 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpOut__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__8" c_qcqpOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__8 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpOut__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__9" c_qcqpOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__9 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpOut__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__10" c_qcqpOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__10 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpOut__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__11" c_qcqpOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__11 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpOut__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__12" c_qcqpOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__12 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qcqpOut__12 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__13" c_qcqpOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qcqpOut__13 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__14" c_qcqpOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__14 + :: String -> MX -> IO (M.Map String MX, Vector String) +qcqpOut__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__15" c_qcqpOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__15 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpOut__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__16" c_qcqpOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__16 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpOut__16 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__16 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__17" c_qcqpOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__17 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpOut__17 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__17 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__18" c_qcqpOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__18 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpOut__18 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__19" c_qcqpOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__19 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qcqpOut__19 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__20" c_qcqpOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__20 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qcqpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__23" c_qcqpOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__23 + :: String -> SX -> IO (M.Map String SX, Vector String) +qcqpOut__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__24" c_qcqpOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__24 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpOut__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__25" c_qcqpOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__25 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpOut__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__26" c_qcqpOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__26 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpOut__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__27" c_qcqpOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__27 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpOut__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__28" c_qcqpOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__28 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qcqpOut__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qcqpOut__29" c_qcqpOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qcqpOut__29 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qcqpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qcqpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__0" c_qpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__1" c_qpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__2" c_qpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__3" c_qpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__4" c_qpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__5" c_qpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__6" c_qpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__7" c_qpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__8" c_qpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__9" c_qpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__10" c_qpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__11" c_qpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__12" c_qpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__13" c_qpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__14" c_qpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__15" c_qpIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__15 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__16" c_qpIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__16 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__17" c_qpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__17 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__18" c_qpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__18 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__19" c_qpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__19 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__20" c_qpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__21" c_qpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__22" c_qpIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__22 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__23" c_qpIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__24" c_qpIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__25" c_qpIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__26" c_qpIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__27" c_qpIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__28" c_qpIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__29" c_qpIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__30" c_qpIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__30 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__31" c_qpIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__31 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__32" c_qpIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__32 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__33" c_qpIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__33 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__34" c_qpIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__34 + :: String -> MX -> IO (M.Map String MX, Vector String) +qpIn__34 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__34 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__35" c_qpIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__35 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__35 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__35 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__36" c_qpIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__36 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__36 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__36 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__37" c_qpIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__37 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__37 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__37 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__38" c_qpIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__38 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__38 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__39" c_qpIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__39 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__39 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__40" c_qpIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__40 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__41" c_qpIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__41 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__42" c_qpIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__42 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__43" c_qpIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__43 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__44" c_qpIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__44 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__45" c_qpIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__45 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__46" c_qpIn__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__46 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__47" c_qpIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__47 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__48" c_qpIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__48 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__49" c_qpIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__49 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__50" c_qpIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__50 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__53" c_qpIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__53 + :: String -> SX -> IO (M.Map String SX, Vector String) +qpIn__53 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__53 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__54" c_qpIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__54 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__54 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__54 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__55" c_qpIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__55 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__55 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__55 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__56" c_qpIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__56 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__56 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__56 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__57" c_qpIn__57 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__57 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__57 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__58" c_qpIn__58 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__58 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__58 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__59" c_qpIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__59 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__60" c_qpIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__60 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__61" c_qpIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__61 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__62" c_qpIn__62 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__62 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__63" c_qpIn__63 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__63 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__64" c_qpIn__64 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__64 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__65" c_qpIn__65 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__65 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__66" c_qpIn__66 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__66 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__67" c_qpIn__67 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__67 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__68" c_qpIn__68 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__68 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpIn__69" c_qpIn__69 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpIn__69 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__0" c_qpOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__1" c_qpOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__2" c_qpOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__3" c_qpOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__4" c_qpOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__5" c_qpOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +qpOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__6" c_qpOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +qpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__7" c_qpOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__7 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpOut__7 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__7 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__8" c_qpOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__8 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpOut__8 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__8 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__9" c_qpOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__9 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpOut__9 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__9 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__10" c_qpOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__10 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpOut__10 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__10 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__11" c_qpOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__11 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpOut__11 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__12" c_qpOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__12 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +qpOut__12 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__13" c_qpOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__13 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +qpOut__13 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__14" c_qpOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__14 + :: String -> MX -> IO (M.Map String MX, Vector String) +qpOut__14 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__14 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__15" c_qpOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__15 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +qpOut__15 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__15 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__16" c_qpOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__16 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpOut__16 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__16 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__17" c_qpOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__17 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpOut__17 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__17 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__18" c_qpOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__18 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpOut__18 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__19" c_qpOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__19 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +qpOut__19 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__20" c_qpOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__20 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +qpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__23" c_qpOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__23 + :: String -> SX -> IO (M.Map String SX, Vector String) +qpOut__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__24" c_qpOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__24 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +qpOut__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__25" c_qpOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__25 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpOut__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__26" c_qpOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__26 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpOut__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__27" c_qpOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__27 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpOut__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__28" c_qpOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__28 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +qpOut__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "qpOut__29" c_qpOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +qpOut__29 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +qpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_qpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__0" c_rdaeIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__1" c_rdaeIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__2" c_rdaeIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__3" c_rdaeIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__4" c_rdaeIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__5" c_rdaeIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__6" c_rdaeIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__7" c_rdaeIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__8" c_rdaeIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__9" c_rdaeIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__10" c_rdaeIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__11" c_rdaeIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__12" c_rdaeIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__13" c_rdaeIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__13 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeIn__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__14" c_rdaeIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__14 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeIn__14 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__14 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__15" c_rdaeIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__15 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeIn__15 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__15 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__16" c_rdaeIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__16 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeIn__16 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__16 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__17" c_rdaeIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeIn__17 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__18" c_rdaeIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeIn__18 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__19" c_rdaeIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeIn__19 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__20" c_rdaeIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__21" c_rdaeIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__22" c_rdaeIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__23" c_rdaeIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__24" c_rdaeIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__25" c_rdaeIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__26" c_rdaeIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__26 + :: String -> MX -> IO (M.Map String MX, Vector String) +rdaeIn__26 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__26 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__27" c_rdaeIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__27 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeIn__27 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__27 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__28" c_rdaeIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__28 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeIn__28 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__28 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__29" c_rdaeIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__29 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeIn__29 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__29 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__30" c_rdaeIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__30 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeIn__30 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__31" c_rdaeIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeIn__31 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__32" c_rdaeIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeIn__32 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__33" c_rdaeIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__33 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__34" c_rdaeIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__34 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__35" c_rdaeIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__35 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__36" c_rdaeIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__36 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__37" c_rdaeIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__37 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__38" c_rdaeIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__38 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__41" c_rdaeIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__41 + :: String -> SX -> IO (M.Map String SX, Vector String) +rdaeIn__41 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__41 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__42" c_rdaeIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__42 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeIn__42 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__42 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__43" c_rdaeIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__43 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeIn__43 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__43 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__44" c_rdaeIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__44 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeIn__44 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__44 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__45" c_rdaeIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__45 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeIn__45 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__46" c_rdaeIn__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__46 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeIn__46 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__47" c_rdaeIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__47 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeIn__47 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__48" c_rdaeIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__48 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__49" c_rdaeIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__49 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__50" c_rdaeIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__50 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__51" c_rdaeIn__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__51 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeIn__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__52" c_rdaeIn__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__52 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeIn__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeIn__53" c_rdaeIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeIn__53 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__0" c_rdaeOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__1" c_rdaeOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__2" c_rdaeOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__3" c_rdaeOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +rdaeOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__4" c_rdaeOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +rdaeOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__5" c_rdaeOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__5 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeOut__5 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__5 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__6" c_rdaeOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__6 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeOut__6 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__6 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__7" c_rdaeOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__7 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeOut__7 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__7 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__8" c_rdaeOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__8 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +rdaeOut__8 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__8 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__9" c_rdaeOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__9 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +rdaeOut__9 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__10" c_rdaeOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__10 + :: String -> MX -> IO (M.Map String MX, Vector String) +rdaeOut__10 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__10 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__11" c_rdaeOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__11 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeOut__11 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__11 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__12" c_rdaeOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__12 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeOut__12 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__12 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__13" c_rdaeOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__13 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +rdaeOut__13 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__13 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__14" c_rdaeOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__14 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +rdaeOut__14 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__14 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__17" c_rdaeOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__17 + :: String -> SX -> IO (M.Map String SX, Vector String) +rdaeOut__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__18" c_rdaeOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__18 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeOut__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__19" c_rdaeOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__19 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeOut__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__20" c_rdaeOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__20 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +rdaeOut__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "rdaeOut__21" c_rdaeOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +rdaeOut__21 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +rdaeOut__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_rdaeOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__0" c_sdpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__1" c_sdpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__2" c_sdpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__3" c_sdpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__4" c_sdpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__5" c_sdpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__6" c_sdpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__7" c_sdpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__8" c_sdpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__9" c_sdpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__10" c_sdpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__11" c_sdpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__12" c_sdpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__13" c_sdpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__14" c_sdpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__15" c_sdpIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__15 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__15 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__15 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__16" c_sdpIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__16 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpIn__16 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__16 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__17" c_sdpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__17 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__17 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__17 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__18" c_sdpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__18 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpIn__18 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__18 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__19" c_sdpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__19 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__20" c_sdpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpIn__20 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__21" c_sdpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__22" c_sdpIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__23" c_sdpIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__24" c_sdpIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__25" c_sdpIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__26" c_sdpIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__27" c_sdpIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__28" c_sdpIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__29" c_sdpIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__30" c_sdpIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__30 + :: String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__30 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__30 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__31" c_sdpIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__31 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpIn__31 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__31 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__32" c_sdpIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__32 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__32 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__32 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__33" c_sdpIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__33 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpIn__33 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__33 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__34" c_sdpIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__34 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__34 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__35" c_sdpIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__35 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpIn__35 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__36" c_sdpIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__36 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__37" c_sdpIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__37 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__38" c_sdpIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__38 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__39" c_sdpIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__39 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__40" c_sdpIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__40 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__41" c_sdpIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__41 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__42" c_sdpIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__42 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__43" c_sdpIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__43 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__44" c_sdpIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__44 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__47" c_sdpIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__47 + :: String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__47 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__47 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__48" c_sdpIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__48 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpIn__48 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__48 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__49" c_sdpIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__49 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__49 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__49 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__50" c_sdpIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__50 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpIn__50 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__50 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__51" c_sdpIn__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__51 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__51 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__52" c_sdpIn__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__52 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpIn__52 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__53" c_sdpIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__53 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__54" c_sdpIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__54 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__55" c_sdpIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__55 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__56" c_sdpIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__56 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__57" c_sdpIn__57 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__57 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__58" c_sdpIn__58 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__58 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__59" c_sdpIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__59 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__60" c_sdpIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__60 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpIn__61" c_sdpIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpIn__61 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__0" c_sdpOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__1" c_sdpOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__2" c_sdpOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__3" c_sdpOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__4" c_sdpOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__5" c_sdpOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__6" c_sdpOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__7" c_sdpOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__8" c_sdpOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__9" c_sdpOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__10" c_sdpOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__11" c_sdpOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdpOut__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__12" c_sdpOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdpOut__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__13" c_sdpOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__13 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpOut__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__14" c_sdpOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__14 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpOut__14 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__14 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__15" c_sdpOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__15 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpOut__15 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__15 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__16" c_sdpOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__16 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpOut__16 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__16 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__17" c_sdpOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpOut__17 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__18" c_sdpOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpOut__18 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__19" c_sdpOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpOut__19 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__20" c_sdpOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__21" c_sdpOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__22" c_sdpOut__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpOut__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__23" c_sdpOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__24" c_sdpOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdpOut__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__25" c_sdpOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdpOut__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__26" c_sdpOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__26 + :: String -> MX -> IO (M.Map String MX, Vector String) +sdpOut__26 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__26 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__27" c_sdpOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__27 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpOut__27 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__27 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__28" c_sdpOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__28 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpOut__28 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__28 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__29" c_sdpOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__29 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpOut__29 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__29 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__30" c_sdpOut__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__30 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpOut__30 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__31" c_sdpOut__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpOut__31 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__32" c_sdpOut__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpOut__32 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__33" c_sdpOut__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__33 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpOut__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__34" c_sdpOut__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__34 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpOut__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__35" c_sdpOut__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__35 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpOut__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__36" c_sdpOut__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__36 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpOut__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__37" c_sdpOut__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__37 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdpOut__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__38" c_sdpOut__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__38 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdpOut__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__41" c_sdpOut__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__41 + :: String -> SX -> IO (M.Map String SX, Vector String) +sdpOut__41 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__41 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__42" c_sdpOut__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__42 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpOut__42 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__42 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__43" c_sdpOut__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__43 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpOut__43 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__43 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__44" c_sdpOut__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__44 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpOut__44 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__44 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__45" c_sdpOut__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__45 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpOut__45 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__46" c_sdpOut__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__46 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpOut__46 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__47" c_sdpOut__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__47 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpOut__47 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__48" c_sdpOut__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__48 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpOut__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__49" c_sdpOut__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__49 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpOut__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__50" c_sdpOut__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__50 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpOut__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__51" c_sdpOut__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__51 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpOut__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__52" c_sdpOut__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__52 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdpOut__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdpOut__53" c_sdpOut__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdpOut__53 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdpOut__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdpOut__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__0" c_sdqpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__1" c_sdqpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__2" c_sdqpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__3" c_sdqpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__4" c_sdqpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__5" c_sdqpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__6" c_sdqpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__7" c_sdqpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__8" c_sdqpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__9" c_sdqpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__10" c_sdqpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__11" c_sdqpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__12" c_sdqpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__13" c_sdqpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__14" c_sdqpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__15" c_sdqpIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__15 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__16" c_sdqpIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__16 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__17" c_sdqpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__17 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__17 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__17 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__18" c_sdqpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__18 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__18 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__18 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__19" c_sdqpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__19 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__19 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__19 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__20" c_sdqpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__20 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__20 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__20 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__21" c_sdqpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__21 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__22" c_sdqpIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__22 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__23" c_sdqpIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__23 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__24" c_sdqpIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__25" c_sdqpIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__26" c_sdqpIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__27" c_sdqpIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__28" c_sdqpIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__29" c_sdqpIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__30" c_sdqpIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__30 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__31" c_sdqpIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__31 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__32" c_sdqpIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__32 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__33" c_sdqpIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__33 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__34" c_sdqpIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__34 + :: String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__34 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__34 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__35" c_sdqpIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__35 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__35 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__35 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__36" c_sdqpIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__36 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__36 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__36 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__37" c_sdqpIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__37 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__37 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__37 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__38" c_sdqpIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__38 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__38 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__39" c_sdqpIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__39 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__39 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__40" c_sdqpIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__40 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__41" c_sdqpIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__41 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__42" c_sdqpIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__42 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__43" c_sdqpIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__43 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__44" c_sdqpIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__44 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__45" c_sdqpIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__45 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__46" c_sdqpIn__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__46 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__47" c_sdqpIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__47 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__48" c_sdqpIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__48 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__49" c_sdqpIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__49 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__50" c_sdqpIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__50 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__53" c_sdqpIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__53 + :: String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__53 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__53 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__54" c_sdqpIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__54 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__54 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__54 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__55" c_sdqpIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__55 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__55 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__55 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__56" c_sdqpIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__56 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__56 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__56 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__57" c_sdqpIn__57 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__57 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__57 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__58" c_sdqpIn__58 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__58 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__58 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__59" c_sdqpIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__59 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__60" c_sdqpIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__60 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__61" c_sdqpIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__61 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__62" c_sdqpIn__62 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__62 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__63" c_sdqpIn__63 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__63 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__64" c_sdqpIn__64 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__64 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__65" c_sdqpIn__65 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__65 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__66" c_sdqpIn__66 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__66 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__67" c_sdqpIn__67 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__67 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__68" c_sdqpIn__68 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__68 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpIn__69" c_sdqpIn__69 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpIn__69 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__0" c_sdqpOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__1" c_sdqpOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__2" c_sdqpOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__3" c_sdqpOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__4" c_sdqpOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__5" c_sdqpOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__6" c_sdqpOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__7" c_sdqpOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__8" c_sdqpOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__9" c_sdqpOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__10" c_sdqpOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__11" c_sdqpOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +sdqpOut__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__12" c_sdqpOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +sdqpOut__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__13" c_sdqpOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__13 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpOut__13 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__13 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__14" c_sdqpOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__14 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpOut__14 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__14 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__15" c_sdqpOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__15 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpOut__15 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__15 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__16" c_sdqpOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__16 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpOut__16 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__16 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__17" c_sdqpOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpOut__17 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__18" c_sdqpOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpOut__18 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__19" c_sdqpOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpOut__19 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__20" c_sdqpOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__21" c_sdqpOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__22" c_sdqpOut__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__22 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpOut__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__23" c_sdqpOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpOut__23 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__23 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__24" c_sdqpOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +sdqpOut__24 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__25" c_sdqpOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +sdqpOut__25 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__26" c_sdqpOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__26 + :: String -> MX -> IO (M.Map String MX, Vector String) +sdqpOut__26 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__26 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__27" c_sdqpOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__27 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpOut__27 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__27 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__28" c_sdqpOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__28 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpOut__28 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__28 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__29" c_sdqpOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__29 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpOut__29 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__29 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__30" c_sdqpOut__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__30 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpOut__30 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__31" c_sdqpOut__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpOut__31 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__32" c_sdqpOut__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpOut__32 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__33" c_sdqpOut__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__33 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpOut__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__34" c_sdqpOut__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__34 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpOut__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__35" c_sdqpOut__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__35 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpOut__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__36" c_sdqpOut__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__36 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpOut__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__37" c_sdqpOut__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__37 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +sdqpOut__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__38" c_sdqpOut__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__38 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +sdqpOut__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__41" c_sdqpOut__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__41 + :: String -> SX -> IO (M.Map String SX, Vector String) +sdqpOut__41 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__41 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__42" c_sdqpOut__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__42 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpOut__42 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__42 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__43" c_sdqpOut__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__43 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpOut__43 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__43 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__44" c_sdqpOut__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__44 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpOut__44 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__44 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__45" c_sdqpOut__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__45 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpOut__45 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__46" c_sdqpOut__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__46 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpOut__46 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__47" c_sdqpOut__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__47 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpOut__47 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__48" c_sdqpOut__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__48 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpOut__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__49" c_sdqpOut__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__49 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpOut__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__50" c_sdqpOut__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__50 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpOut__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__51" c_sdqpOut__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__51 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpOut__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__52" c_sdqpOut__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__52 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +sdqpOut__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "sdqpOut__53" c_sdqpOut__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +sdqpOut__53 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +sdqpOut__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_sdqpOut__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIRK__0" c_simpleIRK__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') +simpleIRK__0 + :: Function -> IO MXFunction +simpleIRK__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIRK__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIRK__1" c_simpleIRK__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MXFunction') +simpleIRK__1 + :: Function -> Int -> IO MXFunction +simpleIRK__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIRK__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIRK__2" c_simpleIRK__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MXFunction') +simpleIRK__2 + :: Function -> Int -> Int -> IO MXFunction +simpleIRK__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIRK__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIRK__3" c_simpleIRK__3 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> IO (Ptr MXFunction') +simpleIRK__3 + :: Function -> Int -> Int -> String -> IO MXFunction +simpleIRK__3 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIRK__3 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIRK__4" c_simpleIRK__4 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> Ptr StdString -> IO (Ptr MXFunction') +simpleIRK__4 + :: Function -> Int -> Int -> String -> String -> IO MXFunction +simpleIRK__4 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIRK__4 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIRK__5" c_simpleIRK__5 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> Ptr StdString -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction') +simpleIRK__5 + :: Function -> Int -> Int -> String -> String -> M.Map String GenericType -> IO MXFunction +simpleIRK__5 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIRK__5 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIntegrator__0" c_simpleIntegrator__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') +simpleIntegrator__0 + :: Function -> IO MXFunction +simpleIntegrator__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIntegrator__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIntegrator__1" c_simpleIntegrator__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr MXFunction') +simpleIntegrator__1 + :: Function -> String -> IO MXFunction +simpleIntegrator__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIntegrator__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleIntegrator__2" c_simpleIntegrator__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> Ptr (StdMap StdString (Ptr GenericType')) -> IO (Ptr MXFunction') +simpleIntegrator__2 + :: Function -> String -> M.Map String GenericType -> IO MXFunction +simpleIntegrator__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleIntegrator__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleRK__0" c_simpleRK__0 + :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr MXFunction') +simpleRK__0 + :: Function -> IO MXFunction +simpleRK__0 x0 = + withMarshal x0 $ \x0' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleRK__0 errStrPtrP x0' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleRK__1" c_simpleRK__1 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> IO (Ptr MXFunction') +simpleRK__1 + :: Function -> Int -> IO MXFunction +simpleRK__1 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleRK__1 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "simpleRK__2" c_simpleRK__2 + :: Ptr (Ptr StdString) -> Ptr Function' -> CInt -> CInt -> IO (Ptr MXFunction') +simpleRK__2 + :: Function -> Int -> Int -> IO MXFunction +simpleRK__2 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_simpleRK__2 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__0" c_socpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__1" c_socpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__2" c_socpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__3" c_socpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__4" c_socpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__5" c_socpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__6" c_socpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__7" c_socpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__8" c_socpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__9" c_socpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__10" c_socpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__11" c_socpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__12" c_socpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__13" c_socpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__14" c_socpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__15" c_socpIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__15 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__16" c_socpIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__16 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__17" c_socpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__17 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__18" c_socpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__18 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__19" c_socpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__19 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__19 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__19 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__20" c_socpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__20 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__20 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__20 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__21" c_socpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__21 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__21 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__21 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__22" c_socpIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__22 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__22 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__22 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__23" c_socpIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__23 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__23 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__23 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__24" c_socpIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__24 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__24 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__24 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__25" c_socpIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__25 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__25 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__25 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__26" c_socpIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__26 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__26 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__27" c_socpIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__27 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__28" c_socpIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__28 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__29" c_socpIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__30" c_socpIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__30 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__31" c_socpIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__31 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__32" c_socpIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__32 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__33" c_socpIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__33 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__34" c_socpIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__34 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__35" c_socpIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__35 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__36" c_socpIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__36 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__37" c_socpIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__37 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__38" c_socpIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__38 + :: String -> MX -> IO (M.Map String MX, Vector String) +socpIn__38 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__38 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__39" c_socpIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__39 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__39 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__39 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__40" c_socpIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__40 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__40 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__40 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__41" c_socpIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__41 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__41 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__41 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__42" c_socpIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__42 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__42 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__43" c_socpIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__43 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__43 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__44" c_socpIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__44 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__45" c_socpIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__45 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__46" c_socpIn__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__46 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__46 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__46 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__47" c_socpIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__47 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__47 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__47 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__48" c_socpIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__48 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__48 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__48 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__49" c_socpIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__49 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__49 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__49 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__50" c_socpIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__50 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__50 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__51" c_socpIn__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__51 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__51 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__52" c_socpIn__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__52 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__52 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__53" c_socpIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__53 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__54" c_socpIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__54 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__55" c_socpIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__55 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__56" c_socpIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__56 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__59" c_socpIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__59 + :: String -> SX -> IO (M.Map String SX, Vector String) +socpIn__59 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__59 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__60" c_socpIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__60 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__60 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__60 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__61" c_socpIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__61 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__61 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__61 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__62" c_socpIn__62 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__62 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__62 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__62 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__63" c_socpIn__63 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__63 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__63 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__64" c_socpIn__64 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__64 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__64 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__65" c_socpIn__65 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__65 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__66" c_socpIn__66 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__66 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__67" c_socpIn__67 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__67 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__68" c_socpIn__68 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__68 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__69" c_socpIn__69 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__69 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__69 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__69 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__70" c_socpIn__70 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__70 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__70 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__70 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__71" c_socpIn__71 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__71 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__71 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__71 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__72" c_socpIn__72 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__72 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__72 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__72 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__73" c_socpIn__73 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__73 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__73 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__73 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__74" c_socpIn__74 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__74 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__74 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__74 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__75" c_socpIn__75 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__75 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__75 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__75 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__76" c_socpIn__76 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__76 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpIn__76 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__76 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpIn__77" c_socpIn__77 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpIn__77 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpIn__77 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpIn__77 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__0" c_socpOut__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpOut__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__1" c_socpOut__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpOut__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__2" c_socpOut__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpOut__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__3" c_socpOut__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpOut__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__4" c_socpOut__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpOut__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__5" c_socpOut__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpOut__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__6" c_socpOut__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpOut__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__7" c_socpOut__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpOut__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__8" c_socpOut__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpOut__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__9" c_socpOut__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpOut__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__10" c_socpOut__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpOut__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__11" c_socpOut__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__11 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpOut__11 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__11 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__12" c_socpOut__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__12 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpOut__12 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__12 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__13" c_socpOut__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__13 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpOut__13 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__13 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__14" c_socpOut__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__14 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpOut__14 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__14 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__15" c_socpOut__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__15 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpOut__15 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__15 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__16" c_socpOut__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__16 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpOut__16 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__17" c_socpOut__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__17 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpOut__17 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__18" c_socpOut__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__18 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpOut__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__19" c_socpOut__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__19 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpOut__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__20" c_socpOut__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__20 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +socpOut__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__21" c_socpOut__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__21 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +socpOut__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__22" c_socpOut__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__22 + :: String -> MX -> IO (M.Map String MX, Vector String) +socpOut__22 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__22 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__23" c_socpOut__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__23 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +socpOut__23 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__23 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__24" c_socpOut__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__24 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpOut__24 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__24 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__25" c_socpOut__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__25 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpOut__25 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__25 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__26" c_socpOut__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__26 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpOut__26 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__26 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__27" c_socpOut__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__27 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpOut__27 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__27 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__28" c_socpOut__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__28 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpOut__28 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__29" c_socpOut__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__29 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpOut__29 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__30" c_socpOut__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__30 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpOut__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__31" c_socpOut__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__31 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +socpOut__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__32" c_socpOut__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__32 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +socpOut__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__35" c_socpOut__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__35 + :: String -> SX -> IO (M.Map String SX, Vector String) +socpOut__35 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__35 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__36" c_socpOut__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__36 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +socpOut__36 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__36 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__37" c_socpOut__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__37 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpOut__37 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__37 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__38" c_socpOut__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__38 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpOut__38 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__38 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__39" c_socpOut__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__39 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpOut__39 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__39 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__40" c_socpOut__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__40 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpOut__40 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__41" c_socpOut__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__41 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpOut__41 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__42" c_socpOut__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__42 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpOut__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__43" c_socpOut__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__43 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpOut__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__44" c_socpOut__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__44 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +socpOut__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpOut__45" c_socpOut__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +socpOut__45 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +socpOut__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpOut__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpStruct__2" c_socpStruct__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpStruct__2 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpStruct__2 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpStruct__2 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpStruct__3" c_socpStruct__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpStruct__3 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpStruct__3 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpStruct__3 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpStruct__4" c_socpStruct__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpStruct__4 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpStruct__4 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpStruct__4 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpStruct__5" c_socpStruct__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpStruct__5 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +socpStruct__5 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpStruct__5 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "socpStruct__6" c_socpStruct__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +socpStruct__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +socpStruct__6 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_socpStruct__6 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__0" c_stabilizedQpIn__0 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__0 + :: String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__0 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__0 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__1" c_stabilizedQpIn__1 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__1 + :: String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__1 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__1 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__2" c_stabilizedQpIn__2 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__2 + :: String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__2 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__2 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__3" c_stabilizedQpIn__3 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__3 + :: String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__3 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__3 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__4" c_stabilizedQpIn__4 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__4 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__4 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__4 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__5" c_stabilizedQpIn__5 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__5 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__5 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__5 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__6" c_stabilizedQpIn__6 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__6 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__6 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__6 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__7" c_stabilizedQpIn__7 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__7 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__7 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__7 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__8" c_stabilizedQpIn__8 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__8 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__8 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__8 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__9" c_stabilizedQpIn__9 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__9 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__9 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__9 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__10" c_stabilizedQpIn__10 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__10 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__10 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__10 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__11" c_stabilizedQpIn__11 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__11 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__11 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__11 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__12" c_stabilizedQpIn__12 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__12 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__12 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__12 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__13" c_stabilizedQpIn__13 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__13 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__13 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__13 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__14" c_stabilizedQpIn__14 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__14 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__14 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__14 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__15" c_stabilizedQpIn__15 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__15 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__15 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__15 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__16" c_stabilizedQpIn__16 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__16 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__16 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__16 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__17" c_stabilizedQpIn__17 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__17 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__17 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__17 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__18" c_stabilizedQpIn__18 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__18 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__18 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__18 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__19" c_stabilizedQpIn__19 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__19 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__19 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__19 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__20" c_stabilizedQpIn__20 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__20 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__20 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__20 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__21" c_stabilizedQpIn__21 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__21 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__21 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__21 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__22" c_stabilizedQpIn__22 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> Ptr StdString -> Ptr Sparsity' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr Sparsity'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__22 + :: String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> String -> Sparsity -> IO (M.Map String Sparsity, Vector String) +stabilizedQpIn__22 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__22 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__23" c_stabilizedQpIn__23 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__23 + :: String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__23 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__23 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__24" c_stabilizedQpIn__24 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__24 + :: String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__24 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__24 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__25" c_stabilizedQpIn__25 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__25 + :: String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__25 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__25 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__26" c_stabilizedQpIn__26 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__26 + :: String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__26 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__26 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__27" c_stabilizedQpIn__27 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__27 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__27 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__27 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__28" c_stabilizedQpIn__28 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__28 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__28 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__28 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__29" c_stabilizedQpIn__29 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__29 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__29 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__29 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__30" c_stabilizedQpIn__30 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__30 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__30 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__30 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__31" c_stabilizedQpIn__31 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__31 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__31 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__31 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__32" c_stabilizedQpIn__32 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__32 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__32 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__32 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__33" c_stabilizedQpIn__33 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__33 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__33 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__33 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__34" c_stabilizedQpIn__34 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__34 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__34 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__34 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__35" c_stabilizedQpIn__35 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__35 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__35 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__35 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__36" c_stabilizedQpIn__36 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__36 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__36 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__36 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__37" c_stabilizedQpIn__37 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__37 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__37 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__37 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__38" c_stabilizedQpIn__38 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__38 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__38 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__38 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__39" c_stabilizedQpIn__39 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__39 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__39 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__39 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__40" c_stabilizedQpIn__40 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__40 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__40 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__40 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__41" c_stabilizedQpIn__41 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__41 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__41 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__41 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__42" c_stabilizedQpIn__42 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__42 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__42 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__42 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__43" c_stabilizedQpIn__43 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__43 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__43 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__43 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__44" c_stabilizedQpIn__44 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__44 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__44 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__44 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__45" c_stabilizedQpIn__45 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> Ptr StdString -> Ptr DMatrix' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr DMatrix'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__45 + :: String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> String -> DMatrix -> IO (M.Map String DMatrix, Vector String) +stabilizedQpIn__45 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__45 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__46" c_stabilizedQpIn__46 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__46 + :: String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__46 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__46 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__47" c_stabilizedQpIn__47 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__47 + :: String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__47 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__47 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__48" c_stabilizedQpIn__48 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__48 + :: String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__48 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__48 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__49" c_stabilizedQpIn__49 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__49 + :: String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__49 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__49 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__50" c_stabilizedQpIn__50 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__50 + :: String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__50 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__50 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__51" c_stabilizedQpIn__51 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__51 + :: String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__51 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__51 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__52" c_stabilizedQpIn__52 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__52 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__52 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__52 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__53" c_stabilizedQpIn__53 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__53 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__53 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__53 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__54" c_stabilizedQpIn__54 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__54 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__54 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__54 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__55" c_stabilizedQpIn__55 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__55 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__55 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__55 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__56" c_stabilizedQpIn__56 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__56 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__56 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__56 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__57" c_stabilizedQpIn__57 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__57 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__57 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__57 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__58" c_stabilizedQpIn__58 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__58 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__58 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__58 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__59" c_stabilizedQpIn__59 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__59 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__59 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__59 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__60" c_stabilizedQpIn__60 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__60 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__60 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__60 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__61" c_stabilizedQpIn__61 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__61 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__61 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__61 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__62" c_stabilizedQpIn__62 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__62 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__62 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__62 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__63" c_stabilizedQpIn__63 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__63 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__63 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__63 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__64" c_stabilizedQpIn__64 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__64 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__64 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__64 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__65" c_stabilizedQpIn__65 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__65 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__65 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__65 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__66" c_stabilizedQpIn__66 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__66 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__66 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__66 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__67" c_stabilizedQpIn__67 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__67 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> IO (M.Map String MX, Vector String) +stabilizedQpIn__67 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__67 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__68" c_stabilizedQpIn__68 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> Ptr StdString -> Ptr MX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr MX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__68 + :: String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> String -> MX -> IO (M.Map String MX, Vector String) +stabilizedQpIn__68 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__68 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__71" c_stabilizedQpIn__71 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__71 + :: String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__71 x0 x1 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__71 errStrPtrP x0' x1' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__72" c_stabilizedQpIn__72 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__72 + :: String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__72 x0 x1 x2 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__72 errStrPtrP x0' x1' x2' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__73" c_stabilizedQpIn__73 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__73 + :: String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__73 x0 x1 x2 x3 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__73 errStrPtrP x0' x1' x2' x3' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__74" c_stabilizedQpIn__74 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__74 + :: String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__74 x0 x1 x2 x3 x4 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__74 errStrPtrP x0' x1' x2' x3' x4' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__75" c_stabilizedQpIn__75 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__75 + :: String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__75 x0 x1 x2 x3 x4 x5 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__75 errStrPtrP x0' x1' x2' x3' x4' x5' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__76" c_stabilizedQpIn__76 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__76 + :: String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__76 x0 x1 x2 x3 x4 x5 x6 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__76 errStrPtrP x0' x1' x2' x3' x4' x5' x6' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__77" c_stabilizedQpIn__77 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__77 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__77 x0 x1 x2 x3 x4 x5 x6 x7 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__77 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__78" c_stabilizedQpIn__78 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__78 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__78 x0 x1 x2 x3 x4 x5 x6 x7 x8 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__78 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__79" c_stabilizedQpIn__79 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__79 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__79 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__79 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__80" c_stabilizedQpIn__80 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__80 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__80 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__80 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__81" c_stabilizedQpIn__81 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__81 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__81 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__81 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__82" c_stabilizedQpIn__82 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__82 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__82 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__82 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__83" c_stabilizedQpIn__83 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__83 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__83 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__83 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__84" c_stabilizedQpIn__84 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__84 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__84 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__84 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__85" c_stabilizedQpIn__85 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__85 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__85 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__85 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__86" c_stabilizedQpIn__86 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__86 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__86 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__86 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__87" c_stabilizedQpIn__87 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__87 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__87 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__87 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__88" c_stabilizedQpIn__88 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__88 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__88 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__88 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__89" c_stabilizedQpIn__89 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__89 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__89 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__89 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__90" c_stabilizedQpIn__90 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__90 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__90 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__90 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__91" c_stabilizedQpIn__91 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__91 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__91 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__91 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__92" c_stabilizedQpIn__92 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__92 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> IO (M.Map String SX, Vector String) +stabilizedQpIn__92 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__92 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' + errStrPtr <- peek errStrPtrP + free errStrPtrP + if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) + + +foreign import ccall unsafe "stabilizedQpIn__93" c_stabilizedQpIn__93 + :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> Ptr StdString -> Ptr SX' -> IO (Ptr (StdPair (Ptr (StdMap StdString (Ptr SX'))) (Ptr (StdVec (Ptr StdString))))) +stabilizedQpIn__93 + :: String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> String -> SX -> IO (M.Map String SX, Vector String) +stabilizedQpIn__93 x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 x10 x11 x12 x13 x14 x15 x16 x17 x18 x19 x20 x21 x22 x23 = + withMarshal x0 $ \x0' -> + withMarshal x1 $ \x1' -> + withMarshal x2 $ \x2' -> + withMarshal x3 $ \x3' -> + withMarshal x4 $ \x4' -> + withMarshal x5 $ \x5' -> + withMarshal x6 $ \x6' -> + withMarshal x7 $ \x7' -> + withMarshal x8 $ \x8' -> + withMarshal x9 $ \x9' -> + withMarshal x10 $ \x10' -> + withMarshal x11 $ \x11' -> + withMarshal x12 $ \x12' -> + withMarshal x13 $ \x13' -> + withMarshal x14 $ \x14' -> + withMarshal x15 $ \x15' -> + withMarshal x16 $ \x16' -> + withMarshal x17 $ \x17' -> + withMarshal x18 $ \x18' -> + withMarshal x19 $ \x19' -> + withMarshal x20 $ \x20' -> + withMarshal x21 $ \x21' -> + withMarshal x22 $ \x22' -> + withMarshal x23 $ \x23' -> + do + errStrPtrP <- new nullPtr + ret <- c_stabilizedQpIn__93 errStrPtrP x0' x1' x2' x3' x4' x5' x6' x7' x8' x9' x10' x11' x12' x13' x14' x15' x16' x17' x18' x19' x20' x21' x22' x23' errStrPtr <- peek errStrPtrP free errStrPtrP if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException) diff --git a/casadi-bindings-core.cabal b/casadi-bindings-core.cabal --- a/casadi-bindings-core.cabal +++ b/casadi-bindings-core.cabal @@ -1,5 +1,5 @@ name: casadi-bindings-core -version: 2.3.0.1 +version: 2.4.1.0 license: LGPL-3 license-file: LICENSE category: Numerical, Math @@ -16,7 +16,8 @@ library build-depends: base >=4.6 && <5, vector >=0.10, - casadi-bindings-internal == 0.1.3.0 + containers >= 0.5, + casadi-bindings-internal == 0.1.3.1 default-language: Haskell2010 @@ -27,7 +28,7 @@ ghc-prof-options: -prof -fprof-auto -fprof-cafs -rtsopts ghc-options: - cc-options: -Wall -Wno-sign-compare + cc-options: -Wall -Wno-sign-compare -std=c++11 C-sources: cbits/custom_wrappers.cpp cbits/autogen/casadi_wrap_classes.cpp @@ -38,39 +39,50 @@ Casadi.Core.Tools Casadi.Core.CustomWrappers Casadi.Core.Classes.Callback + Casadi.Core.Classes.Callback2 Casadi.Core.Classes.CasadiMeta Casadi.Core.Classes.CasadiOptions Casadi.Core.Classes.CleSolver + Casadi.Core.Classes.CodeGenerator + Casadi.Core.Classes.Compiler Casadi.Core.Classes.ControlSimulator Casadi.Core.Classes.CustomEvaluate Casadi.Core.Classes.CustomFunction Casadi.Core.Classes.DMatrix + Casadi.Core.Classes.DaeBuilder Casadi.Core.Classes.DerivativeGenerator + Casadi.Core.Classes.DerivativeGenerator2 Casadi.Core.Classes.DleSolver Casadi.Core.Classes.DpleSolver Casadi.Core.Classes.ExternalFunction Casadi.Core.Classes.Function Casadi.Core.Classes.Functor + Casadi.Core.Classes.GenericExpressionCommon + Casadi.Core.Classes.GenericMatrixCommon Casadi.Core.Classes.GenericType Casadi.Core.Classes.HomotopyNlpSolver Casadi.Core.Classes.IMatrix - Casadi.Core.Classes.IOScheme Casadi.Core.Classes.ImplicitFunction Casadi.Core.Classes.Integrator + Casadi.Core.Classes.IterationCallback + Casadi.Core.Classes.KernelSum2D Casadi.Core.Classes.LinearSolver Casadi.Core.Classes.LpSolver Casadi.Core.Classes.LrDleSolver Casadi.Core.Classes.LrDpleSolver Casadi.Core.Classes.MX - Casadi.Core.Classes.MXAlgEl Casadi.Core.Classes.MXFunction + Casadi.Core.Classes.Map + Casadi.Core.Classes.MapAccum + Casadi.Core.Classes.MatrixCommon + Casadi.Core.Classes.NlpBuilder Casadi.Core.Classes.NlpSolver Casadi.Core.Classes.Nullspace Casadi.Core.Classes.OptionsFunctionality - Casadi.Core.Classes.Parallelizer Casadi.Core.Classes.QcqpSolver Casadi.Core.Classes.QpSolver Casadi.Core.Classes.SX + Casadi.Core.Classes.SXElement Casadi.Core.Classes.SXFunction Casadi.Core.Classes.SdpSolver Casadi.Core.Classes.SdqpSolver @@ -79,9 +91,9 @@ Casadi.Core.Classes.Slice Casadi.Core.Classes.SocpSolver Casadi.Core.Classes.Sparsity + Casadi.Core.Classes.SparsityInterfaceCommon Casadi.Core.Classes.StabilizedQpSolver - Casadi.Core.Classes.SymbolicNLP - Casadi.Core.Classes.SymbolicOCP + Casadi.Core.Classes.Switch Casadi.Core.Classes.Variable Casadi.Core.Classes.XmlFile Casadi.Core.Classes.IOInterfaceFunction diff --git a/cbits/autogen/casadi_wrap_classes.cpp b/cbits/autogen/casadi_wrap_classes.cpp # file too large to diff: cbits/autogen/casadi_wrap_classes.cpp diff --git a/cbits/autogen/casadi_wrap_functions.cpp b/cbits/autogen/casadi_wrap_functions.cpp # file too large to diff: cbits/autogen/casadi_wrap_functions.cpp diff --git a/cbits/custom_wrappers.cpp b/cbits/custom_wrappers.cpp --- a/cbits/custom_wrappers.cpp +++ b/cbits/custom_wrappers.cpp @@ -3,16 +3,16 @@ #include #include "marshal.hpp" -extern "C" -std::string * casadi__custom__generateCode(std::string ** err_msg, casadi::Function* obj, int x0); -std::string * casadi__custom__generateCode(std::string ** err_msg, casadi::Function* obj, int x0){ - try { - bool x0_ = Marshaling::marshal(x0); - std::stringstream ret; - obj->generateCode(ret, x0_); - return new std::string(ret.str()); - } catch (std::exception& ex) { - *err_msg = new std::string(ex.what()); - return 0; - } -} +//extern "C" +//std::string * casadi__custom__generateCode(std::string ** err_msg, casadi::Function* obj, int x0); +//std::string * casadi__custom__generateCode(std::string ** err_msg, casadi::Function* obj, int x0){ +// try { +// bool x0_ = Marshaling::marshal(x0); +// std::stringstream ret; +// obj->generateCode(ret, x0_); +// return new std::string(ret.str()); +// } catch (std::exception& ex) { +// *err_msg = new std::string(ex.what()); +// return 0; +// } +//} diff --git a/cbits/marshal.hpp b/cbits/marshal.hpp --- a/cbits/marshal.hpp +++ b/cbits/marshal.hpp @@ -40,8 +40,33 @@ } }; +template +class Marshaling< std::pair< TX1, TY1 >, std::pair< TX2, TY2 > > { + public: + static std::pair< TX1, TY1 > marshal(const std::pair< TX2, TY2 > inputs){ + TX1 x = Marshaling< TX1, TX2 >::marshal(inputs.first); + TY1 y = Marshaling< TY1, TY2 >::marshal(inputs.second); + return std::pair(x, y); + } +}; template +class Marshaling< std::map< std::string, T1 >, std::map< std::string, T2 > > { + public: + static std::map< std::string, T1 > marshal(const std::map< std::string, T2 > inputs){ + std::map< std::string, T1 > ret; + typename std::map::const_iterator it; + for (it = inputs.begin(); it != inputs.end(); it++) { + std::string key = it->first; + T1 val = Marshaling< T1, T2 >::marshal(it->second); + std::pair keyVal(key, val); + ret.insert(keyVal); + } + return ret; + } +}; + +template class Marshaling< T1, T2* > { public: static T1 marshal(T2* x){ @@ -67,6 +92,32 @@ vec.push_back( WrapReturn< T1, T2 >::wrapReturn(inputs[k]) ); } return vec; + } +}; + +template +class WrapReturn< std::map< std::string, T1 >, std::map< std::string, T2 > > { + public: + static std::map< std::string, T1 > wrapReturn(std::map< std::string, T2 > inputs){ + std::map< std::string, T1 > ret; + typename std::map::iterator it; + for (it = inputs.begin(); it != inputs.end(); it++) { + std::string key = it->first; + T1 val = WrapReturn< T1, T2 >::wrapReturn(it->second); + std::pair keyVal(key, val); + ret.insert(keyVal); + } + return ret; + } +}; + +template +class WrapReturn< std::pair< T1X, T1Y >, std::pair< T2X, T2Y > > { + public: + static std::pair< T1X, T1Y > wrapReturn(std::pair< T2X, T2Y > inputs){ + T1X x = WrapReturn< T1X, T2X >::wrapReturn(inputs.first); + T1Y y = WrapReturn< T1Y, T2Y >::wrapReturn(inputs.second); + return std::pair< T1X, T1Y >(x, y); } };