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
@@ -23,7 +23,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -32,8 +31,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Callback where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__Callback__CONSTRUCTOR" c_casadi__Callback__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr Callback')
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
@@ -10,11 +10,11 @@
CasadiOptions,
CasadiOptionsClass(..),
casadiOptions_getAllowedInternalAPI,
- casadiOptions_getCatchErrorsPython,
+ casadiOptions_getCatchErrorsSwig,
casadiOptions_getProfilingBinary,
casadiOptions_getSimplificationOnTheFly,
casadiOptions_setAllowedInternalAPI,
- casadiOptions_setCatchErrorsPython,
+ casadiOptions_setCatchErrorsSwig,
casadiOptions_setProfilingBinary,
casadiOptions_setPurgeSeeds__0,
casadiOptions_setPurgeSeeds__1,
@@ -63,23 +63,23 @@
-- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__getCatchErrorsPython" c_casadi__CasadiOptions__getCatchErrorsPython
+foreign import ccall unsafe "casadi__CasadiOptions__getCatchErrorsSwig" c_casadi__CasadiOptions__getCatchErrorsSwig
:: Ptr (Ptr StdString) -> IO CInt
-casadi__CasadiOptions__getCatchErrorsPython
+casadi__CasadiOptions__getCatchErrorsSwig
:: IO Bool
-casadi__CasadiOptions__getCatchErrorsPython =
+casadi__CasadiOptions__getCatchErrorsSwig =
do
errStrPtrP <- new nullPtr
- ret <- c_casadi__CasadiOptions__getCatchErrorsPython errStrPtrP
+ ret <- c_casadi__CasadiOptions__getCatchErrorsSwig errStrPtrP
errStrPtr <- peek errStrPtrP
free errStrPtrP
if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-- classy wrapper
-casadiOptions_getCatchErrorsPython :: IO Bool
-casadiOptions_getCatchErrorsPython = casadi__CasadiOptions__getCatchErrorsPython
+casadiOptions_getCatchErrorsSwig :: IO Bool
+casadiOptions_getCatchErrorsSwig = casadi__CasadiOptions__getCatchErrorsSwig
-- direct wrapper
@@ -143,23 +143,23 @@
-- direct wrapper
-foreign import ccall unsafe "casadi__CasadiOptions__setCatchErrorsPython" c_casadi__CasadiOptions__setCatchErrorsPython
+foreign import ccall unsafe "casadi__CasadiOptions__setCatchErrorsSwig" c_casadi__CasadiOptions__setCatchErrorsSwig
:: Ptr (Ptr StdString) -> CInt -> IO ()
-casadi__CasadiOptions__setCatchErrorsPython
+casadi__CasadiOptions__setCatchErrorsSwig
:: Bool -> IO ()
-casadi__CasadiOptions__setCatchErrorsPython x0 =
+casadi__CasadiOptions__setCatchErrorsSwig x0 =
withMarshal x0 $ \x0' ->
do
errStrPtrP <- new nullPtr
- ret <- c_casadi__CasadiOptions__setCatchErrorsPython errStrPtrP x0'
+ ret <- c_casadi__CasadiOptions__setCatchErrorsSwig errStrPtrP x0'
errStrPtr <- peek errStrPtrP
free errStrPtrP
if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-- classy wrapper
-casadiOptions_setCatchErrorsPython :: Bool -> IO ()
-casadiOptions_setCatchErrorsPython = casadi__CasadiOptions__setCatchErrorsPython
+casadiOptions_setCatchErrorsSwig :: Bool -> IO ()
+casadiOptions_setCatchErrorsSwig = casadi__CasadiOptions__setCatchErrorsSwig
-- direct wrapper
diff --git a/Casadi/Core/Classes/CleSolver.hs b/Casadi/Core/Classes/CleSolver.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/CleSolver.hs
@@ -0,0 +1,136 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.CleSolver
+ (
+ CleSolver,
+ CleSolverClass(..),
+ cleSolver,
+ cleSolver_clone,
+ cleSolver_doc,
+ cleSolver_loadPlugin,
+ cleSolver_printStats,
+ ) 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__CleSolver__CONSTRUCTOR" c_casadi__CleSolver__CONSTRUCTOR
+ :: Ptr (Ptr StdString) -> IO (Ptr CleSolver')
+casadi__CleSolver__CONSTRUCTOR
+ :: IO CleSolver
+casadi__CleSolver__CONSTRUCTOR =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__CleSolver__CONSTRUCTOR 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
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__CleSolver__clone" c_casadi__CleSolver__clone
+ :: Ptr (Ptr StdString) -> Ptr CleSolver' -> IO (Ptr CleSolver')
+casadi__CleSolver__clone
+ :: CleSolver -> IO CleSolver
+casadi__CleSolver__clone x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__CleSolver__clone errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+cleSolver_clone :: CleSolverClass a => a -> IO CleSolver
+cleSolver_clone x = casadi__CleSolver__clone (castCleSolver x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__CleSolver__doc" c_casadi__CleSolver__doc
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+casadi__CleSolver__doc
+ :: String -> IO String
+casadi__CleSolver__doc x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__CleSolver__doc errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+cleSolver_doc :: String -> IO String
+cleSolver_doc = casadi__CleSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__CleSolver__loadPlugin" c_casadi__CleSolver__loadPlugin
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+casadi__CleSolver__loadPlugin
+ :: String -> IO ()
+casadi__CleSolver__loadPlugin x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__CleSolver__loadPlugin errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+cleSolver_loadPlugin :: String -> IO ()
+cleSolver_loadPlugin = casadi__CleSolver__loadPlugin
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__CleSolver__printStats" c_casadi__CleSolver__printStats
+ :: Ptr (Ptr StdString) -> Ptr CleSolver' -> IO ()
+casadi__CleSolver__printStats
+ :: CleSolver -> IO ()
+casadi__CleSolver__printStats x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__CleSolver__printStats errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+cleSolver_printStats :: CleSolverClass a => a -> IO ()
+cleSolver_printStats x = casadi__CleSolver__printStats (castCleSolver 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
@@ -30,7 +30,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -39,8 +38,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show ControlSimulator where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
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
@@ -23,7 +23,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -32,8 +31,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show CustomEvaluate where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__CustomEvaluate__CONSTRUCTOR" c_casadi__CustomEvaluate__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr CustomEvaluate')
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
@@ -25,7 +25,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -34,8 +33,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show CustomFunction where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__CustomFunction__CONSTRUCTOR__0" c_casadi__CustomFunction__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr CustomEvaluate' -> IO (Ptr CustomFunction')
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
@@ -169,6 +169,7 @@
dmatrix_mul_full__1,
dmatrix_mul_no_alloc_nn__0,
dmatrix_mul_no_alloc_nn__1,
+ dmatrix_mul_no_alloc_nn__2,
dmatrix_mul_no_alloc_nt,
dmatrix_mul_no_alloc_tn__0,
dmatrix_mul_no_alloc_tn__1,
@@ -319,7 +320,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -328,8 +328,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show DMatrix where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__CONSTRUCTOR__0" c_casadi__DMatrix__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr DMatrix')
@@ -3654,27 +3652,50 @@
-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__mul_no_alloc_nn__1" c_casadi__DMatrix__mul_no_alloc_nn__1
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO ()
casadi__DMatrix__mul_no_alloc_nn__1
- :: DMatrix -> DMatrix -> DMatrix -> IO ()
-casadi__DMatrix__mul_no_alloc_nn__1 x0 x1 x2 =
+ :: DMatrix -> DMatrix -> DMatrix -> Vector Double -> IO ()
+casadi__DMatrix__mul_no_alloc_nn__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__mul_no_alloc_nn__1 errStrPtrP x0' x1' x2'
+ ret <- c_casadi__DMatrix__mul_no_alloc_nn__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_mul_no_alloc_nn__1 :: DMatrix -> DMatrix -> DMatrix -> IO ()
+dmatrix_mul_no_alloc_nn__1 :: DMatrix -> DMatrix -> DMatrix -> Vector Double -> IO ()
dmatrix_mul_no_alloc_nn__1 = casadi__DMatrix__mul_no_alloc_nn__1
-- direct wrapper
+foreign import ccall unsafe "casadi__DMatrix__mul_no_alloc_nn__2" c_casadi__DMatrix__mul_no_alloc_nn__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
+casadi__DMatrix__mul_no_alloc_nn__2
+ :: DMatrix -> DMatrix -> DMatrix -> IO ()
+casadi__DMatrix__mul_no_alloc_nn__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DMatrix__mul_no_alloc_nn__2 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dmatrix_mul_no_alloc_nn__2 :: DMatrix -> DMatrix -> DMatrix -> IO ()
+dmatrix_mul_no_alloc_nn__2 = casadi__DMatrix__mul_no_alloc_nn__2
+
+
+-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__mul_no_alloc_nt" c_casadi__DMatrix__mul_no_alloc_nt
:: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr DMatrix' -> IO ()
casadi__DMatrix__mul_no_alloc_nt
@@ -4262,9 +4283,9 @@
-- direct wrapper
foreign import ccall unsafe "casadi__DMatrix__quad_form" c_casadi__DMatrix__quad_form
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> IO CDouble
+ :: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> Ptr DMatrix' -> IO CDouble
casadi__DMatrix__quad_form
- :: DMatrix -> Vector Double -> IO Double
+ :: Vector Double -> DMatrix -> IO Double
casadi__DMatrix__quad_form x0 x1 =
withMarshal x0 $ \x0' ->
withMarshal x1 $ \x1' ->
@@ -4277,7 +4298,7 @@
-- classy wrapper
-dmatrix_quad_form :: DMatrix -> Vector Double -> IO Double
+dmatrix_quad_form :: Vector Double -> DMatrix -> IO Double
dmatrix_quad_form = casadi__DMatrix__quad_form
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
@@ -23,7 +23,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -32,8 +31,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show DerivativeGenerator where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__DerivativeGenerator__CONSTRUCTOR" c_casadi__DerivativeGenerator__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr DerivativeGenerator')
diff --git a/Casadi/Core/Classes/DleSolver.hs b/Casadi/Core/Classes/DleSolver.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/DleSolver.hs
@@ -0,0 +1,157 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.DleSolver
+ (
+ DleSolver,
+ DleSolverClass(..),
+ dleSolver,
+ dleSolver_clone,
+ dleSolver_doc,
+ dleSolver_infix,
+ dleSolver_loadPlugin,
+ dleSolver_printStats,
+ ) 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__DleSolver__CONSTRUCTOR" c_casadi__DleSolver__CONSTRUCTOR
+ :: Ptr (Ptr StdString) -> IO (Ptr DleSolver')
+casadi__DleSolver__CONSTRUCTOR
+ :: IO DleSolver
+casadi__DleSolver__CONSTRUCTOR =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DleSolver__CONSTRUCTOR 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
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DleSolver__clone" c_casadi__DleSolver__clone
+ :: Ptr (Ptr StdString) -> Ptr DleSolver' -> IO (Ptr DleSolver')
+casadi__DleSolver__clone
+ :: DleSolver -> IO DleSolver
+casadi__DleSolver__clone x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DleSolver__clone errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dleSolver_clone :: DleSolverClass a => a -> IO DleSolver
+dleSolver_clone x = casadi__DleSolver__clone (castDleSolver x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DleSolver__doc" c_casadi__DleSolver__doc
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+casadi__DleSolver__doc
+ :: String -> IO String
+casadi__DleSolver__doc x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DleSolver__doc errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dleSolver_doc :: String -> IO String
+dleSolver_doc = casadi__DleSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DleSolver__infix" c_casadi__DleSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__DleSolver__infix
+ :: IO String
+casadi__DleSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DleSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dleSolver_infix :: IO String
+dleSolver_infix = casadi__DleSolver__infix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DleSolver__loadPlugin" c_casadi__DleSolver__loadPlugin
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+casadi__DleSolver__loadPlugin
+ :: String -> IO ()
+casadi__DleSolver__loadPlugin x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DleSolver__loadPlugin errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dleSolver_loadPlugin :: String -> IO ()
+dleSolver_loadPlugin = casadi__DleSolver__loadPlugin
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DleSolver__printStats" c_casadi__DleSolver__printStats
+ :: Ptr (Ptr StdString) -> Ptr DleSolver' -> IO ()
+casadi__DleSolver__printStats
+ :: DleSolver -> IO ()
+casadi__DleSolver__printStats x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DleSolver__printStats errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dleSolver_printStats :: DleSolverClass a => a -> IO ()
+dleSolver_printStats x = casadi__DleSolver__printStats (castDleSolver x)
+
diff --git a/Casadi/Core/Classes/DpleSolver.hs b/Casadi/Core/Classes/DpleSolver.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/DpleSolver.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.DpleSolver
+ (
+ DpleSolver,
+ DpleSolverClass(..),
+ dpleSolver__0,
+ dpleSolver__1,
+ dpleSolver_clone,
+ dpleSolver_doc,
+ dpleSolver_infix,
+ dpleSolver_loadPlugin,
+ dpleSolver_printStats,
+ ) 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__DpleSolver__CONSTRUCTOR__0" c_casadi__DpleSolver__CONSTRUCTOR__0
+ :: Ptr (Ptr StdString) -> Ptr StdString -> Ptr (StdVec (Ptr Sparsity')) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr DpleSolver')
+casadi__DpleSolver__CONSTRUCTOR__0
+ :: String -> Vector Sparsity -> Vector Sparsity -> IO DpleSolver
+casadi__DpleSolver__CONSTRUCTOR__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DpleSolver__CONSTRUCTOR__0 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dpleSolver__0 :: String -> Vector Sparsity -> 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')
+casadi__DpleSolver__CONSTRUCTOR__1
+ :: IO DpleSolver
+casadi__DpleSolver__CONSTRUCTOR__1 =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DpleSolver__CONSTRUCTOR__1 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
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DpleSolver__clone" c_casadi__DpleSolver__clone
+ :: Ptr (Ptr StdString) -> Ptr DpleSolver' -> IO (Ptr DpleSolver')
+casadi__DpleSolver__clone
+ :: DpleSolver -> IO DpleSolver
+casadi__DpleSolver__clone x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DpleSolver__clone errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dpleSolver_clone :: DpleSolverClass a => a -> IO DpleSolver
+dpleSolver_clone x = casadi__DpleSolver__clone (castDpleSolver x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DpleSolver__doc" c_casadi__DpleSolver__doc
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+casadi__DpleSolver__doc
+ :: String -> IO String
+casadi__DpleSolver__doc x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DpleSolver__doc errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dpleSolver_doc :: String -> IO String
+dpleSolver_doc = casadi__DpleSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DpleSolver__infix" c_casadi__DpleSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__DpleSolver__infix
+ :: IO String
+casadi__DpleSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DpleSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dpleSolver_infix :: IO String
+dpleSolver_infix = casadi__DpleSolver__infix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DpleSolver__loadPlugin" c_casadi__DpleSolver__loadPlugin
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+casadi__DpleSolver__loadPlugin
+ :: String -> IO ()
+casadi__DpleSolver__loadPlugin x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DpleSolver__loadPlugin errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dpleSolver_loadPlugin :: String -> IO ()
+dpleSolver_loadPlugin = casadi__DpleSolver__loadPlugin
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__DpleSolver__printStats" c_casadi__DpleSolver__printStats
+ :: Ptr (Ptr StdString) -> Ptr DpleSolver' -> IO ()
+casadi__DpleSolver__printStats
+ :: DpleSolver -> IO ()
+casadi__DpleSolver__printStats x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__DpleSolver__printStats errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+dpleSolver_printStats :: DpleSolverClass a => a -> IO ()
+dpleSolver_printStats x = casadi__DpleSolver__printStats (castDpleSolver x)
+
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
@@ -24,7 +24,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -33,8 +32,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show ExternalFunction where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__ExternalFunction__CONSTRUCTOR__0" c_casadi__ExternalFunction__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr ExternalFunction')
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
@@ -36,6 +36,7 @@
function_fullJacobian,
function_generateCode__0,
function_generateCode__1,
+ function_generateCode__2,
function_getInputScheme,
function_getNumInputElements,
function_getNumInputNonzeros,
@@ -134,7 +135,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -143,8 +143,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Function where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__Function__CONSTRUCTOR" c_casadi__Function__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr Function')
@@ -769,6 +767,28 @@
-- classy wrapper
function_generateCode__1 :: FunctionClass a => a -> String -> IO ()
function_generateCode__1 x = casadi__Function__generateCode__1 (castFunction x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Function__generateCode__2" c_casadi__Function__generateCode__2
+ :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> CInt -> IO ()
+casadi__Function__generateCode__2
+ :: Function -> String -> Bool -> IO ()
+casadi__Function__generateCode__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Function__generateCode__2 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+function_generateCode__2 :: FunctionClass a => a -> String -> Bool -> IO ()
+function_generateCode__2 x = casadi__Function__generateCode__2 (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
@@ -22,7 +22,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -30,6 +29,3 @@
import Casadi.Internal.WrapReturn ( WrapReturn(..) )
import Casadi.Core.Data
import Casadi.Core.Enums
-
-instance Show Functor where
- show = unsafePerformIO . printableObject_getDescription
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
@@ -62,7 +62,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -71,8 +70,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show GenericType where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__GenericType__CONSTRUCTOR__0" c_casadi__GenericType__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr Callback' -> IO (Ptr GenericType')
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
@@ -25,7 +25,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -34,8 +33,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show HomotopyNlpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__HomotopyNlpSolver__CONSTRUCTOR" c_casadi__HomotopyNlpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr HomotopyNlpSolver')
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
@@ -166,6 +166,7 @@
imatrix_mul_full__1,
imatrix_mul_no_alloc_nn__0,
imatrix_mul_no_alloc_nn__1,
+ imatrix_mul_no_alloc_nn__2,
imatrix_mul_no_alloc_nt,
imatrix_mul_no_alloc_tn__0,
imatrix_mul_no_alloc_tn__1,
@@ -316,7 +317,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -325,8 +325,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show IMatrix where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__CONSTRUCTOR__0" c_casadi__IMatrix__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> CInt -> CInt -> IO (Ptr IMatrix')
@@ -3589,27 +3587,50 @@
-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_nn__1" c_casadi__IMatrix__mul_no_alloc_nn__1
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO ()
casadi__IMatrix__mul_no_alloc_nn__1
- :: IMatrix -> IMatrix -> IMatrix -> IO ()
-casadi__IMatrix__mul_no_alloc_nn__1 x0 x1 x2 =
+ :: IMatrix -> IMatrix -> IMatrix -> Vector Int -> IO ()
+casadi__IMatrix__mul_no_alloc_nn__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__mul_no_alloc_nn__1 errStrPtrP x0' x1' x2'
+ ret <- c_casadi__IMatrix__mul_no_alloc_nn__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_mul_no_alloc_nn__1 :: IMatrix -> IMatrix -> IMatrix -> IO ()
+imatrix_mul_no_alloc_nn__1 :: IMatrix -> IMatrix -> IMatrix -> Vector Int -> IO ()
imatrix_mul_no_alloc_nn__1 = casadi__IMatrix__mul_no_alloc_nn__1
-- direct wrapper
+foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_nn__2" c_casadi__IMatrix__mul_no_alloc_nn__2
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
+casadi__IMatrix__mul_no_alloc_nn__2
+ :: IMatrix -> IMatrix -> IMatrix -> IO ()
+casadi__IMatrix__mul_no_alloc_nn__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__IMatrix__mul_no_alloc_nn__2 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+imatrix_mul_no_alloc_nn__2 :: IMatrix -> IMatrix -> IMatrix -> IO ()
+imatrix_mul_no_alloc_nn__2 = casadi__IMatrix__mul_no_alloc_nn__2
+
+
+-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__mul_no_alloc_nt" c_casadi__IMatrix__mul_no_alloc_nt
:: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr IMatrix' -> IO ()
casadi__IMatrix__mul_no_alloc_nt
@@ -4197,9 +4218,9 @@
-- direct wrapper
foreign import ccall unsafe "casadi__IMatrix__quad_form" c_casadi__IMatrix__quad_form
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO CInt
+ :: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr IMatrix' -> IO CInt
casadi__IMatrix__quad_form
- :: IMatrix -> Vector Int -> IO Int
+ :: Vector Int -> IMatrix -> IO Int
casadi__IMatrix__quad_form x0 x1 =
withMarshal x0 $ \x0' ->
withMarshal x1 $ \x1' ->
@@ -4212,7 +4233,7 @@
-- classy wrapper
-imatrix_quad_form :: IMatrix -> Vector Int -> IO Int
+imatrix_quad_form :: Vector Int -> IMatrix -> IO Int
imatrix_quad_form = casadi__IMatrix__quad_form
diff --git a/Casadi/Core/Classes/IOScheme.hs b/Casadi/Core/Classes/IOScheme.hs
--- a/Casadi/Core/Classes/IOScheme.hs
+++ b/Casadi/Core/Classes/IOScheme.hs
@@ -58,7 +58,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -67,8 +66,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show IOScheme where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__IOScheme__CONSTRUCTOR__0" c_casadi__IOScheme__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr IOScheme')
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
@@ -31,7 +31,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -40,8 +39,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show ImplicitFunction where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
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
@@ -35,7 +35,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -44,8 +43,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Integrator where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
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
@@ -38,7 +38,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -47,8 +46,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show LinearSolver where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
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
@@ -25,7 +25,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -34,8 +33,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show LpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__LpSolver__CONSTRUCTOR" c_casadi__LpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr LpSolver')
diff --git a/Casadi/Core/Classes/LrDleSolver.hs b/Casadi/Core/Classes/LrDleSolver.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/LrDleSolver.hs
@@ -0,0 +1,157 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.LrDleSolver
+ (
+ LrDleSolver,
+ LrDleSolverClass(..),
+ lrDleSolver,
+ lrDleSolver_clone,
+ lrDleSolver_doc,
+ lrDleSolver_infix,
+ lrDleSolver_loadPlugin,
+ lrDleSolver_printStats,
+ ) 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__LrDleSolver__CONSTRUCTOR" c_casadi__LrDleSolver__CONSTRUCTOR
+ :: Ptr (Ptr StdString) -> IO (Ptr LrDleSolver')
+casadi__LrDleSolver__CONSTRUCTOR
+ :: IO LrDleSolver
+casadi__LrDleSolver__CONSTRUCTOR =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDleSolver__CONSTRUCTOR 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
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDleSolver__clone" c_casadi__LrDleSolver__clone
+ :: Ptr (Ptr StdString) -> Ptr LrDleSolver' -> IO (Ptr LrDleSolver')
+casadi__LrDleSolver__clone
+ :: LrDleSolver -> IO LrDleSolver
+casadi__LrDleSolver__clone x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDleSolver__clone errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDleSolver_clone :: LrDleSolverClass a => a -> IO LrDleSolver
+lrDleSolver_clone x = casadi__LrDleSolver__clone (castLrDleSolver x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDleSolver__doc" c_casadi__LrDleSolver__doc
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+casadi__LrDleSolver__doc
+ :: String -> IO String
+casadi__LrDleSolver__doc x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDleSolver__doc errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDleSolver_doc :: String -> IO String
+lrDleSolver_doc = casadi__LrDleSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDleSolver__infix" c_casadi__LrDleSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__LrDleSolver__infix
+ :: IO String
+casadi__LrDleSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDleSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDleSolver_infix :: IO String
+lrDleSolver_infix = casadi__LrDleSolver__infix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDleSolver__loadPlugin" c_casadi__LrDleSolver__loadPlugin
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+casadi__LrDleSolver__loadPlugin
+ :: String -> IO ()
+casadi__LrDleSolver__loadPlugin x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDleSolver__loadPlugin errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDleSolver_loadPlugin :: String -> IO ()
+lrDleSolver_loadPlugin = casadi__LrDleSolver__loadPlugin
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDleSolver__printStats" c_casadi__LrDleSolver__printStats
+ :: Ptr (Ptr StdString) -> Ptr LrDleSolver' -> IO ()
+casadi__LrDleSolver__printStats
+ :: LrDleSolver -> IO ()
+casadi__LrDleSolver__printStats x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDleSolver__printStats errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDleSolver_printStats :: LrDleSolverClass a => a -> IO ()
+lrDleSolver_printStats x = casadi__LrDleSolver__printStats (castLrDleSolver x)
+
diff --git a/Casadi/Core/Classes/LrDpleSolver.hs b/Casadi/Core/Classes/LrDpleSolver.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/LrDpleSolver.hs
@@ -0,0 +1,157 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.LrDpleSolver
+ (
+ LrDpleSolver,
+ LrDpleSolverClass(..),
+ lrDpleSolver,
+ lrDpleSolver_clone,
+ lrDpleSolver_doc,
+ lrDpleSolver_infix,
+ lrDpleSolver_loadPlugin,
+ lrDpleSolver_printStats,
+ ) 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__LrDpleSolver__CONSTRUCTOR" c_casadi__LrDpleSolver__CONSTRUCTOR
+ :: Ptr (Ptr StdString) -> IO (Ptr LrDpleSolver')
+casadi__LrDpleSolver__CONSTRUCTOR
+ :: IO LrDpleSolver
+casadi__LrDpleSolver__CONSTRUCTOR =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDpleSolver__CONSTRUCTOR 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
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDpleSolver__clone" c_casadi__LrDpleSolver__clone
+ :: Ptr (Ptr StdString) -> Ptr LrDpleSolver' -> IO (Ptr LrDpleSolver')
+casadi__LrDpleSolver__clone
+ :: LrDpleSolver -> IO LrDpleSolver
+casadi__LrDpleSolver__clone x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDpleSolver__clone errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDpleSolver_clone :: LrDpleSolverClass a => a -> IO LrDpleSolver
+lrDpleSolver_clone x = casadi__LrDpleSolver__clone (castLrDpleSolver x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDpleSolver__doc" c_casadi__LrDpleSolver__doc
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+casadi__LrDpleSolver__doc
+ :: String -> IO String
+casadi__LrDpleSolver__doc x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDpleSolver__doc errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDpleSolver_doc :: String -> IO String
+lrDpleSolver_doc = casadi__LrDpleSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDpleSolver__infix" c_casadi__LrDpleSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__LrDpleSolver__infix
+ :: IO String
+casadi__LrDpleSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDpleSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDpleSolver_infix :: IO String
+lrDpleSolver_infix = casadi__LrDpleSolver__infix
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDpleSolver__loadPlugin" c_casadi__LrDpleSolver__loadPlugin
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+casadi__LrDpleSolver__loadPlugin
+ :: String -> IO ()
+casadi__LrDpleSolver__loadPlugin x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDpleSolver__loadPlugin errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDpleSolver_loadPlugin :: String -> IO ()
+lrDpleSolver_loadPlugin = casadi__LrDpleSolver__loadPlugin
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__LrDpleSolver__printStats" c_casadi__LrDpleSolver__printStats
+ :: Ptr (Ptr StdString) -> Ptr LrDpleSolver' -> IO ()
+casadi__LrDpleSolver__printStats
+ :: LrDpleSolver -> IO ()
+casadi__LrDpleSolver__printStats x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__LrDpleSolver__printStats errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+lrDpleSolver_printStats :: LrDpleSolverClass a => a -> IO ()
+lrDpleSolver_printStats x = casadi__LrDpleSolver__printStats (castLrDpleSolver x)
+
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
@@ -275,7 +275,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -284,8 +283,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show MX where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__MX__CONSTRUCTOR__0" c_casadi__MX__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr MX')
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
@@ -67,7 +67,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -76,8 +75,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show MXFunction where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
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
@@ -16,6 +16,7 @@
nlpSolver_getReportConstraints,
nlpSolver_gradF,
nlpSolver_hessLag,
+ nlpSolver_infix,
nlpSolver_jacG,
nlpSolver_joinFG,
nlpSolver_loadPlugin,
@@ -36,7 +37,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -45,8 +45,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show NlpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
@@ -186,6 +184,26 @@
-- classy wrapper
nlpSolver_hessLag :: NlpSolverClass a => a -> IO Function
nlpSolver_hessLag x = casadi__NlpSolver__hessLag (castNlpSolver x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__NlpSolver__infix" c_casadi__NlpSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__NlpSolver__infix
+ :: IO String
+casadi__NlpSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__NlpSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+nlpSolver_infix :: IO String
+nlpSolver_infix = casadi__NlpSolver__infix
-- direct wrapper
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
@@ -23,7 +23,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -32,8 +31,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Nullspace where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__Nullspace__CONSTRUCTOR" c_casadi__Nullspace__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr Nullspace')
diff --git a/Casadi/Core/Classes/OCPSolver.hs b/Casadi/Core/Classes/OCPSolver.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/OCPSolver.hs
+++ /dev/null
@@ -1,139 +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.OCPSolver
- (
- OCPSolver,
- OCPSolverClass(..),
- ocpSolver,
- ocpSolver_getCfcn,
- ocpSolver_getFfcn,
- ocpSolver_getMfcn,
- ocpSolver_getRfcn,
- ) 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.Core.Classes.PrintableObject
-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
-
-instance Show OCPSolver where
- show = unsafePerformIO . printableObject_getDescription
--- direct wrapper
-foreign import ccall unsafe "casadi__OCPSolver__CONSTRUCTOR" c_casadi__OCPSolver__CONSTRUCTOR
- :: Ptr (Ptr StdString) -> IO (Ptr OCPSolver')
-casadi__OCPSolver__CONSTRUCTOR
- :: IO OCPSolver
-casadi__OCPSolver__CONSTRUCTOR =
-
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__OCPSolver__CONSTRUCTOR errStrPtrP
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ocpSolver :: IO OCPSolver
-ocpSolver = casadi__OCPSolver__CONSTRUCTOR
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OCPSolver__getCfcn" c_casadi__OCPSolver__getCfcn
- :: Ptr (Ptr StdString) -> Ptr OCPSolver' -> IO (Ptr Function')
-casadi__OCPSolver__getCfcn
- :: OCPSolver -> IO Function
-casadi__OCPSolver__getCfcn x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__OCPSolver__getCfcn errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ocpSolver_getCfcn :: OCPSolverClass a => a -> IO Function
-ocpSolver_getCfcn x = casadi__OCPSolver__getCfcn (castOCPSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OCPSolver__getFfcn" c_casadi__OCPSolver__getFfcn
- :: Ptr (Ptr StdString) -> Ptr OCPSolver' -> IO (Ptr Function')
-casadi__OCPSolver__getFfcn
- :: OCPSolver -> IO Function
-casadi__OCPSolver__getFfcn x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__OCPSolver__getFfcn errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ocpSolver_getFfcn :: OCPSolverClass a => a -> IO Function
-ocpSolver_getFfcn x = casadi__OCPSolver__getFfcn (castOCPSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OCPSolver__getMfcn" c_casadi__OCPSolver__getMfcn
- :: Ptr (Ptr StdString) -> Ptr OCPSolver' -> IO (Ptr Function')
-casadi__OCPSolver__getMfcn
- :: OCPSolver -> IO Function
-casadi__OCPSolver__getMfcn x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__OCPSolver__getMfcn errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ocpSolver_getMfcn :: OCPSolverClass a => a -> IO Function
-ocpSolver_getMfcn x = casadi__OCPSolver__getMfcn (castOCPSolver x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__OCPSolver__getRfcn" c_casadi__OCPSolver__getRfcn
- :: Ptr (Ptr StdString) -> Ptr OCPSolver' -> IO (Ptr Function')
-casadi__OCPSolver__getRfcn
- :: OCPSolver -> IO Function
-casadi__OCPSolver__getRfcn x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__OCPSolver__getRfcn errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-ocpSolver_getRfcn :: OCPSolverClass a => a -> IO Function
-ocpSolver_getRfcn x = casadi__OCPSolver__getRfcn (castOCPSolver x)
-
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
@@ -40,7 +40,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -49,8 +48,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show OptionsFunctionality where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__OptionsFunctionality__CONSTRUCTOR" c_casadi__OptionsFunctionality__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr OptionsFunctionality')
diff --git a/Casadi/Core/Classes/Parallelizer.hs b/Casadi/Core/Classes/Parallelizer.hs
--- a/Casadi/Core/Classes/Parallelizer.hs
+++ b/Casadi/Core/Classes/Parallelizer.hs
@@ -24,7 +24,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -33,8 +32,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Parallelizer where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
diff --git a/Casadi/Core/Classes/PrintableObject.hs b/Casadi/Core/Classes/PrintableObject.hs
deleted file mode 100644
--- a/Casadi/Core/Classes/PrintableObject.hs
+++ /dev/null
@@ -1,75 +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.PrintableObject
- (
- PrintableObject,
- PrintableObjectClass(..),
- printableObject_getDescription,
- printableObject_getRepresentation,
- ) 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
-
-instance Show PrintableObject where
- show = unsafePerformIO . printableObject_getDescription
--- direct wrapper
-foreign import ccall unsafe "casadi__PrintableObject__getDescription" c_casadi__PrintableObject__getDescription
- :: Ptr (Ptr StdString) -> Ptr PrintableObject' -> IO (Ptr StdString)
-casadi__PrintableObject__getDescription
- :: PrintableObject -> IO String
-casadi__PrintableObject__getDescription x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__PrintableObject__getDescription errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-printableObject_getDescription :: PrintableObjectClass a => a -> IO String
-printableObject_getDescription x = casadi__PrintableObject__getDescription (castPrintableObject x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__PrintableObject__getRepresentation" c_casadi__PrintableObject__getRepresentation
- :: Ptr (Ptr StdString) -> Ptr PrintableObject' -> IO (Ptr StdString)
-casadi__PrintableObject__getRepresentation
- :: PrintableObject -> IO String
-casadi__PrintableObject__getRepresentation x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__PrintableObject__getRepresentation errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-printableObject_getRepresentation :: PrintableObjectClass a => a -> IO String
-printableObject_getRepresentation x = casadi__PrintableObject__getRepresentation (castPrintableObject x)
-
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
@@ -11,6 +11,7 @@
QcqpSolverClass(..),
qcqpSolver,
qcqpSolver_doc,
+ qcqpSolver_infix,
qcqpSolver_loadPlugin,
qcqpSolver_setQPOptions,
) where
@@ -26,7 +27,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -35,8 +35,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show QcqpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__QcqpSolver__CONSTRUCTOR" c_casadi__QcqpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr QcqpSolver')
@@ -75,6 +73,26 @@
-- classy wrapper
qcqpSolver_doc :: String -> IO String
qcqpSolver_doc = casadi__QcqpSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__QcqpSolver__infix" c_casadi__QcqpSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__QcqpSolver__infix
+ :: IO String
+casadi__QcqpSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__QcqpSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+qcqpSolver_infix :: IO String
+qcqpSolver_infix = casadi__QcqpSolver__infix
-- direct wrapper
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
@@ -12,6 +12,7 @@
qpSolver,
qpSolver_doc,
qpSolver_generateNativeCode,
+ qpSolver_infix,
qpSolver_loadPlugin,
qpSolver_setLPOptions,
) where
@@ -27,7 +28,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -36,8 +36,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show QpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__QpSolver__CONSTRUCTOR" c_casadi__QpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr QpSolver')
@@ -97,6 +95,26 @@
-- classy wrapper
qpSolver_generateNativeCode :: QpSolverClass a => a -> String -> IO ()
qpSolver_generateNativeCode x = casadi__QpSolver__generateNativeCode (castQpSolver x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__QpSolver__infix" c_casadi__QpSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__QpSolver__infix
+ :: IO String
+casadi__QpSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__QpSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+qpSolver_infix :: IO String
+qpSolver_infix = casadi__QpSolver__infix
-- direct wrapper
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
@@ -172,6 +172,7 @@
sx_mul_full__1,
sx_mul_no_alloc_nn__0,
sx_mul_no_alloc_nn__1,
+ sx_mul_no_alloc_nn__2,
sx_mul_no_alloc_nt,
sx_mul_no_alloc_tn__0,
sx_mul_no_alloc_tn__1,
@@ -322,7 +323,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -331,8 +331,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show SX where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__SX__CONSTRUCTOR__0" c_casadi__SX__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr (StdVec CDouble) -> CInt -> CInt -> IO (Ptr SX')
@@ -3719,27 +3717,50 @@
-- direct wrapper
foreign import ccall unsafe "casadi__SX__mul_no_alloc_nn__1" c_casadi__SX__mul_no_alloc_nn__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> IO ()
casadi__SX__mul_no_alloc_nn__1
- :: SX -> SX -> SX -> IO ()
-casadi__SX__mul_no_alloc_nn__1 x0 x1 x2 =
+ :: SX -> SX -> SX -> Vector SXElement -> IO ()
+casadi__SX__mul_no_alloc_nn__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__mul_no_alloc_nn__1 errStrPtrP x0' x1' x2'
+ ret <- c_casadi__SX__mul_no_alloc_nn__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_mul_no_alloc_nn__1 :: SX -> SX -> SX -> IO ()
+sx_mul_no_alloc_nn__1 :: SX -> SX -> SX -> Vector SXElement -> IO ()
sx_mul_no_alloc_nn__1 = casadi__SX__mul_no_alloc_nn__1
-- direct wrapper
+foreign import ccall unsafe "casadi__SX__mul_no_alloc_nn__2" c_casadi__SX__mul_no_alloc_nn__2
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
+casadi__SX__mul_no_alloc_nn__2
+ :: SX -> SX -> SX -> IO ()
+casadi__SX__mul_no_alloc_nn__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SX__mul_no_alloc_nn__2 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+sx_mul_no_alloc_nn__2 :: SX -> SX -> SX -> IO ()
+sx_mul_no_alloc_nn__2 = casadi__SX__mul_no_alloc_nn__2
+
+
+-- direct wrapper
foreign import ccall unsafe "casadi__SX__mul_no_alloc_nt" c_casadi__SX__mul_no_alloc_nt
:: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
casadi__SX__mul_no_alloc_nt
@@ -4327,9 +4348,9 @@
-- direct wrapper
foreign import ccall unsafe "casadi__SX__quad_form" c_casadi__SX__quad_form
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> IO (Ptr SXElement')
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SXElement')) -> Ptr SX' -> IO (Ptr SXElement')
casadi__SX__quad_form
- :: SX -> Vector SXElement -> IO SXElement
+ :: Vector SXElement -> SX -> IO SXElement
casadi__SX__quad_form x0 x1 =
withMarshal x0 $ \x0' ->
withMarshal x1 $ \x1' ->
@@ -4342,7 +4363,7 @@
-- classy wrapper
-sx_quad_form :: SX -> Vector SXElement -> IO SXElement
+sx_quad_form :: Vector SXElement -> SX -> IO SXElement
sx_quad_form = casadi__SX__quad_form
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
@@ -76,7 +76,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -85,8 +84,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show SXFunction where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
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
@@ -11,6 +11,7 @@
SdpSolverClass(..),
sdpSolver,
sdpSolver_doc,
+ sdpSolver_infix,
sdpSolver_loadPlugin,
sdpSolver_setSOCPOptions,
) where
@@ -26,7 +27,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -35,8 +35,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show SdpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__SdpSolver__CONSTRUCTOR" c_casadi__SdpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr SdpSolver')
@@ -75,6 +73,26 @@
-- classy wrapper
sdpSolver_doc :: String -> IO String
sdpSolver_doc = casadi__SdpSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SdpSolver__infix" c_casadi__SdpSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__SdpSolver__infix
+ :: IO String
+casadi__SdpSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SdpSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+sdpSolver_infix :: IO String
+sdpSolver_infix = casadi__SdpSolver__infix
-- direct wrapper
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
@@ -26,7 +26,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -35,8 +34,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show SdqpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__SdqpSolver__CONSTRUCTOR" c_casadi__SdqpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr SdqpSolver')
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
@@ -10,7 +10,6 @@
SharedObject,
SharedObjectClass(..),
sharedObject_assertInit,
- sharedObject_checkNode,
sharedObject_init__0,
sharedObject_init__1,
sharedObject_isInit,
@@ -31,7 +30,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -40,8 +38,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show SharedObject where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__SharedObject__assertInit" c_casadi__SharedObject__assertInit
:: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO ()
@@ -60,26 +56,6 @@
-- classy wrapper
sharedObject_assertInit :: SharedObjectClass a => a -> IO ()
sharedObject_assertInit x = casadi__SharedObject__assertInit (castSharedObject x)
-
-
--- direct wrapper
-foreign import ccall unsafe "casadi__SharedObject__checkNode" c_casadi__SharedObject__checkNode
- :: Ptr (Ptr StdString) -> Ptr SharedObject' -> IO CInt
-casadi__SharedObject__checkNode
- :: SharedObject -> IO Bool
-casadi__SharedObject__checkNode x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_casadi__SharedObject__checkNode errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
--- classy wrapper
-sharedObject_checkNode :: SharedObjectClass a => a -> IO Bool
-sharedObject_checkNode x = casadi__SharedObject__checkNode (castSharedObject x)
-- direct wrapper
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
@@ -27,7 +27,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -36,8 +35,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Simulator where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
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
@@ -32,7 +32,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -41,8 +40,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Slice where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__Slice__CONSTRUCTOR__0" c_casadi__Slice__CONSTRUCTOR__0
:: Ptr (Ptr StdString) -> Ptr (StdVec CInt) -> Ptr Slice' -> IO (Ptr Slice')
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
@@ -11,6 +11,7 @@
SocpSolverClass(..),
socpSolver,
socpSolver_doc,
+ socpSolver_infix,
socpSolver_loadPlugin,
) where
@@ -25,7 +26,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -34,8 +34,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show SocpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__SocpSolver__CONSTRUCTOR" c_casadi__SocpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr SocpSolver')
@@ -74,6 +72,26 @@
-- classy wrapper
socpSolver_doc :: String -> IO String
socpSolver_doc = casadi__SocpSolver__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SocpSolver__infix" c_casadi__SocpSolver__infix
+ :: Ptr (Ptr StdString) -> IO (Ptr StdString)
+casadi__SocpSolver__infix
+ :: IO String
+casadi__SocpSolver__infix =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SocpSolver__infix errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+socpSolver_infix :: IO String
+socpSolver_infix = casadi__SocpSolver__infix
-- 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
@@ -16,6 +16,8 @@
sparsity_appendColumns,
sparsity_band,
sparsity_banded,
+ sparsity_bandwidthL,
+ sparsity_bandwidthU,
sparsity_clearCache,
sparsity_colind__0,
sparsity_colind__1,
@@ -81,6 +83,7 @@
sparsity_patternIntersection__1,
sparsity_patternInverse,
sparsity_patternProduct,
+ sparsity_patternProductNew,
sparsity_patternUnion__0,
sparsity_patternUnion__1,
sparsity_pmult__0,
@@ -145,7 +148,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -154,8 +156,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show Sparsity where
- show = unsafePerformIO . printableObject_getDescription
-- 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')
@@ -304,6 +304,46 @@
-- 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
@@ -1677,6 +1717,27 @@
-- 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__patternProductNew" c_casadi__Sparsity__patternProductNew
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+casadi__Sparsity__patternProductNew
+ :: Sparsity -> Sparsity -> IO Sparsity
+casadi__Sparsity__patternProductNew x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Sparsity__patternProductNew errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+sparsity_patternProductNew :: SparsityClass a => a -> Sparsity -> IO Sparsity
+sparsity_patternProductNew x = casadi__Sparsity__patternProductNew (castSparsity x)
-- direct wrapper
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
@@ -27,7 +27,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -36,8 +35,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show StabilizedQpSolver where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__StabilizedQpSolver__CONSTRUCTOR" c_casadi__StabilizedQpSolver__CONSTRUCTOR
:: Ptr (Ptr StdString) -> IO (Ptr StabilizedQpSolver')
diff --git a/Casadi/Core/Classes/SymbolicNLP.hs b/Casadi/Core/Classes/SymbolicNLP.hs
--- a/Casadi/Core/Classes/SymbolicNLP.hs
+++ b/Casadi/Core/Classes/SymbolicNLP.hs
@@ -23,7 +23,6 @@
import Foreign.ForeignPtr ( newForeignPtr )
import System.IO.Unsafe ( unsafePerformIO ) -- for show instances
-import Casadi.Core.Classes.PrintableObject
import Casadi.Internal.CToolsInstances ( )
import Casadi.Internal.FormatException ( formatException )
import Casadi.Internal.MarshalTypes ( StdVec, StdString) -- StdPair StdOstream'
@@ -32,8 +31,6 @@
import Casadi.Core.Data
import Casadi.Core.Enums
-instance Show SymbolicNLP where
- show = unsafePerformIO . printableObject_getDescription
-- direct wrapper
foreign import ccall unsafe "casadi__SymbolicNLP__parseNL" c_casadi__SymbolicNLP__parseNL
:: Ptr (Ptr StdString) -> Ptr SymbolicNLP' -> Ptr StdString -> IO ()
diff --git a/Casadi/Core/Classes/SymbolicOCP.hs b/Casadi/Core/Classes/SymbolicOCP.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/SymbolicOCP.hs
@@ -0,0 +1,1654 @@
+{-# 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__0,
+ symbolicOCP__1,
+ symbolicOCP_addVariable,
+ symbolicOCP_atTime__0,
+ symbolicOCP_atTime__1,
+ symbolicOCP_atTime__2,
+ symbolicOCP_atTime__3,
+ symbolicOCP_beq__0,
+ symbolicOCP_beq__1,
+ symbolicOCP_der__0,
+ symbolicOCP_der__1,
+ symbolicOCP_derivativeStart__0,
+ symbolicOCP_derivativeStart__1,
+ symbolicOCP_derivativeStart__2,
+ symbolicOCP_derivativeStart__3,
+ symbolicOCP_eliminateAlgebraic,
+ symbolicOCP_eliminateDependentParameterInterdependencies,
+ symbolicOCP_eliminateDependentParameters,
+ symbolicOCP_eliminateIndependentParameters,
+ symbolicOCP_eliminateLagrangeTerms,
+ symbolicOCP_eliminateOutputInterdependencies,
+ symbolicOCP_eliminateOutputs,
+ symbolicOCP_eliminateQuadratureStates,
+ symbolicOCP_generateMuscodDatFile,
+ symbolicOCP_initialGuess__0,
+ symbolicOCP_initialGuess__1,
+ symbolicOCP_makeExplicit,
+ symbolicOCP_makeSemiExplicit,
+ symbolicOCP_max__0,
+ symbolicOCP_max__1,
+ symbolicOCP_min__0,
+ symbolicOCP_min__1,
+ symbolicOCP_nominal__0,
+ symbolicOCP_nominal__1,
+ symbolicOCP_ode__0,
+ symbolicOCP_ode__1,
+ symbolicOCP_parseFMI,
+ symbolicOCP_scaleEquations,
+ symbolicOCP_scaleVariables,
+ symbolicOCP_separateAlgebraic,
+ symbolicOCP_setBeq__0,
+ symbolicOCP_setBeq__1,
+ symbolicOCP_setDerivativeStart__0,
+ symbolicOCP_setDerivativeStart__1,
+ symbolicOCP_setDerivativeStart__2,
+ symbolicOCP_setDerivativeStart__3,
+ symbolicOCP_setInitialGuess__0,
+ symbolicOCP_setInitialGuess__1,
+ symbolicOCP_setMax__0,
+ symbolicOCP_setMax__1,
+ symbolicOCP_setMin__0,
+ symbolicOCP_setMin__1,
+ symbolicOCP_setNominal__0,
+ symbolicOCP_setNominal__1,
+ symbolicOCP_setOde__0,
+ symbolicOCP_setOde__1,
+ symbolicOCP_setStart__0,
+ symbolicOCP_setStart__1,
+ symbolicOCP_setStart__2,
+ symbolicOCP_setStart__3,
+ symbolicOCP_setUnit,
+ symbolicOCP_sortALG,
+ symbolicOCP_sortDAE,
+ symbolicOCP_sortDependentParameters,
+ symbolicOCP_sortOutputs,
+ 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__0" c_casadi__SymbolicOCP__CONSTRUCTOR__0
+ :: Ptr (Ptr StdString) -> IO (Ptr SymbolicOCP')
+casadi__SymbolicOCP__CONSTRUCTOR__0
+ :: IO SymbolicOCP
+casadi__SymbolicOCP__CONSTRUCTOR__0 =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__CONSTRUCTOR__0 errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP__0 :: IO SymbolicOCP
+symbolicOCP__0 = casadi__SymbolicOCP__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__CONSTRUCTOR__1" c_casadi__SymbolicOCP__CONSTRUCTOR__1
+ :: Ptr (Ptr StdString) -> CInt -> IO (Ptr SymbolicOCP')
+casadi__SymbolicOCP__CONSTRUCTOR__1
+ :: Bool -> IO SymbolicOCP
+casadi__SymbolicOCP__CONSTRUCTOR__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__CONSTRUCTOR__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP__1 :: Bool -> IO SymbolicOCP
+symbolicOCP__1 = casadi__SymbolicOCP__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__addVariable" c_casadi__SymbolicOCP__addVariable
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> Ptr Variable' -> IO ()
+casadi__SymbolicOCP__addVariable
+ :: SymbolicOCP -> String -> Variable -> IO ()
+casadi__SymbolicOCP__addVariable x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__addVariable errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_addVariable :: SymbolicOCPClass a => a -> String -> Variable -> IO ()
+symbolicOCP_addVariable x = casadi__SymbolicOCP__addVariable (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__atTime__0" c_casadi__SymbolicOCP__atTime__0
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO (Ptr SX')
+casadi__SymbolicOCP__atTime__0
+ :: SymbolicOCP -> String -> Double -> IO SX
+casadi__SymbolicOCP__atTime__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__atTime__0 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_atTime__0 :: SymbolicOCPClass a => a -> String -> Double -> IO SX
+symbolicOCP_atTime__0 x = casadi__SymbolicOCP__atTime__0 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__atTime__1" c_casadi__SymbolicOCP__atTime__1
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO (Ptr SX')
+casadi__SymbolicOCP__atTime__1
+ :: SymbolicOCP -> String -> Double -> Bool -> IO SX
+casadi__SymbolicOCP__atTime__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__atTime__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_atTime__1 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO SX
+symbolicOCP_atTime__1 x = casadi__SymbolicOCP__atTime__1 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__atTime__2" c_casadi__SymbolicOCP__atTime__2
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> IO (Ptr SX')
+casadi__SymbolicOCP__atTime__2
+ :: SymbolicOCP -> String -> Double -> IO SX
+casadi__SymbolicOCP__atTime__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__atTime__2 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_atTime__2 :: SymbolicOCPClass a => a -> String -> Double -> IO SX
+symbolicOCP_atTime__2 x = casadi__SymbolicOCP__atTime__2 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__atTime__3" c_casadi__SymbolicOCP__atTime__3
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> CDouble -> CInt -> IO (Ptr SX')
+casadi__SymbolicOCP__atTime__3
+ :: SymbolicOCP -> String -> Double -> Bool -> IO SX
+casadi__SymbolicOCP__atTime__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__atTime__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_atTime__3 :: SymbolicOCPClass a => a -> String -> Double -> Bool -> IO SX
+symbolicOCP_atTime__3 x = casadi__SymbolicOCP__atTime__3 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__beq__0" c_casadi__SymbolicOCP__beq__0
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
+casadi__SymbolicOCP__beq__0
+ :: SymbolicOCP -> SX -> IO SX
+casadi__SymbolicOCP__beq__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__beq__0 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_beq__0 :: SymbolicOCPClass a => a -> SX -> IO SX
+symbolicOCP_beq__0 x = casadi__SymbolicOCP__beq__0 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__beq__1" c_casadi__SymbolicOCP__beq__1
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
+casadi__SymbolicOCP__beq__1
+ :: SymbolicOCP -> String -> IO SX
+casadi__SymbolicOCP__beq__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__beq__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_beq__1 :: SymbolicOCPClass a => a -> String -> IO SX
+symbolicOCP_beq__1 x = casadi__SymbolicOCP__beq__1 (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__eliminateAlgebraic" c_casadi__SymbolicOCP__eliminateAlgebraic
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateAlgebraic
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateAlgebraic x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateAlgebraic errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateAlgebraic :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateAlgebraic x = casadi__SymbolicOCP__eliminateAlgebraic (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__eliminateDependentParameterInterdependencies" c_casadi__SymbolicOCP__eliminateDependentParameterInterdependencies
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateDependentParameterInterdependencies
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateDependentParameterInterdependencies x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateDependentParameterInterdependencies errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateDependentParameterInterdependencies :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateDependentParameterInterdependencies x = casadi__SymbolicOCP__eliminateDependentParameterInterdependencies (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__eliminateDependentParameters" c_casadi__SymbolicOCP__eliminateDependentParameters
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateDependentParameters
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateDependentParameters x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateDependentParameters errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateDependentParameters :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateDependentParameters x = casadi__SymbolicOCP__eliminateDependentParameters (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__eliminateIndependentParameters" c_casadi__SymbolicOCP__eliminateIndependentParameters
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateIndependentParameters
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateIndependentParameters x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateIndependentParameters errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateIndependentParameters :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateIndependentParameters x = casadi__SymbolicOCP__eliminateIndependentParameters (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__eliminateLagrangeTerms" c_casadi__SymbolicOCP__eliminateLagrangeTerms
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateLagrangeTerms
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateLagrangeTerms x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateLagrangeTerms errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateLagrangeTerms :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateLagrangeTerms x = casadi__SymbolicOCP__eliminateLagrangeTerms (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__eliminateOutputInterdependencies" c_casadi__SymbolicOCP__eliminateOutputInterdependencies
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateOutputInterdependencies
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateOutputInterdependencies x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateOutputInterdependencies errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateOutputInterdependencies :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateOutputInterdependencies x = casadi__SymbolicOCP__eliminateOutputInterdependencies (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__eliminateOutputs" c_casadi__SymbolicOCP__eliminateOutputs
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateOutputs
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateOutputs x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateOutputs errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateOutputs :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateOutputs x = casadi__SymbolicOCP__eliminateOutputs (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__eliminateQuadratureStates" c_casadi__SymbolicOCP__eliminateQuadratureStates
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__eliminateQuadratureStates
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__eliminateQuadratureStates x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__eliminateQuadratureStates errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_eliminateQuadratureStates :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_eliminateQuadratureStates x = casadi__SymbolicOCP__eliminateQuadratureStates (castSymbolicOCP x)
+
+
+-- 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 SX')
+casadi__SymbolicOCP__initialGuess__0
+ :: SymbolicOCP -> SX -> IO SX
+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 SX
+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 StdString -> IO (Ptr SX')
+casadi__SymbolicOCP__initialGuess__1
+ :: SymbolicOCP -> String -> IO SX
+casadi__SymbolicOCP__initialGuess__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__initialGuess__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_initialGuess__1 :: SymbolicOCPClass a => a -> String -> IO SX
+symbolicOCP_initialGuess__1 x = casadi__SymbolicOCP__initialGuess__1 (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 SX')
+casadi__SymbolicOCP__max__0
+ :: SymbolicOCP -> SX -> IO SX
+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 SX
+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 StdString -> IO (Ptr SX')
+casadi__SymbolicOCP__max__1
+ :: SymbolicOCP -> String -> IO SX
+casadi__SymbolicOCP__max__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__max__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_max__1 :: SymbolicOCPClass a => a -> String -> IO SX
+symbolicOCP_max__1 x = casadi__SymbolicOCP__max__1 (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 SX')
+casadi__SymbolicOCP__min__0
+ :: SymbolicOCP -> SX -> IO SX
+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 SX
+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 StdString -> IO (Ptr SX')
+casadi__SymbolicOCP__min__1
+ :: SymbolicOCP -> String -> IO SX
+casadi__SymbolicOCP__min__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__min__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_min__1 :: SymbolicOCPClass a => a -> String -> IO SX
+symbolicOCP_min__1 x = casadi__SymbolicOCP__min__1 (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__ode__0" c_casadi__SymbolicOCP__ode__0
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> IO (Ptr SX')
+casadi__SymbolicOCP__ode__0
+ :: SymbolicOCP -> SX -> IO SX
+casadi__SymbolicOCP__ode__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__ode__0 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_ode__0 :: SymbolicOCPClass a => a -> SX -> IO SX
+symbolicOCP_ode__0 x = casadi__SymbolicOCP__ode__0 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__ode__1" c_casadi__SymbolicOCP__ode__1
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> IO (Ptr SX')
+casadi__SymbolicOCP__ode__1
+ :: SymbolicOCP -> String -> IO SX
+casadi__SymbolicOCP__ode__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__ode__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_ode__1 :: SymbolicOCPClass a => a -> String -> IO SX
+symbolicOCP_ode__1 x = casadi__SymbolicOCP__ode__1 (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__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__separateAlgebraic" c_casadi__SymbolicOCP__separateAlgebraic
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__separateAlgebraic
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__separateAlgebraic x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__separateAlgebraic errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_separateAlgebraic :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_separateAlgebraic x = casadi__SymbolicOCP__separateAlgebraic (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__setBeq__0" c_casadi__SymbolicOCP__setBeq__0
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr SX' -> IO ()
+casadi__SymbolicOCP__setBeq__0
+ :: SymbolicOCP -> SX -> SX -> IO ()
+casadi__SymbolicOCP__setBeq__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__setBeq__0 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_setBeq__0 :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
+symbolicOCP_setBeq__0 x = casadi__SymbolicOCP__setBeq__0 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__setBeq__1" c_casadi__SymbolicOCP__setBeq__1
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> Ptr SX' -> IO ()
+casadi__SymbolicOCP__setBeq__1
+ :: SymbolicOCP -> String -> SX -> IO ()
+casadi__SymbolicOCP__setBeq__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__setBeq__1 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_setBeq__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
+symbolicOCP_setBeq__1 x = casadi__SymbolicOCP__setBeq__1 (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 SX' -> IO ()
+casadi__SymbolicOCP__setInitialGuess__0
+ :: SymbolicOCP -> SX -> SX -> 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 -> SX -> 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 StdString -> Ptr SX' -> IO ()
+casadi__SymbolicOCP__setInitialGuess__1
+ :: SymbolicOCP -> String -> SX -> IO ()
+casadi__SymbolicOCP__setInitialGuess__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__setInitialGuess__1 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_setInitialGuess__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
+symbolicOCP_setInitialGuess__1 x = casadi__SymbolicOCP__setInitialGuess__1 (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 SX' -> IO ()
+casadi__SymbolicOCP__setMax__0
+ :: SymbolicOCP -> SX -> SX -> 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 -> SX -> 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 StdString -> Ptr SX' -> IO ()
+casadi__SymbolicOCP__setMax__1
+ :: SymbolicOCP -> String -> SX -> IO ()
+casadi__SymbolicOCP__setMax__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__setMax__1 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_setMax__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
+symbolicOCP_setMax__1 x = casadi__SymbolicOCP__setMax__1 (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 SX' -> IO ()
+casadi__SymbolicOCP__setMin__0
+ :: SymbolicOCP -> SX -> SX -> 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 -> SX -> 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 StdString -> Ptr SX' -> IO ()
+casadi__SymbolicOCP__setMin__1
+ :: SymbolicOCP -> String -> SX -> IO ()
+casadi__SymbolicOCP__setMin__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__setMin__1 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_setMin__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
+symbolicOCP_setMin__1 x = casadi__SymbolicOCP__setMin__1 (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__setOde__0" c_casadi__SymbolicOCP__setOde__0
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr SX' -> Ptr SX' -> IO ()
+casadi__SymbolicOCP__setOde__0
+ :: SymbolicOCP -> SX -> SX -> IO ()
+casadi__SymbolicOCP__setOde__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__setOde__0 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_setOde__0 :: SymbolicOCPClass a => a -> SX -> SX -> IO ()
+symbolicOCP_setOde__0 x = casadi__SymbolicOCP__setOde__0 (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__setOde__1" c_casadi__SymbolicOCP__setOde__1
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> Ptr StdString -> Ptr SX' -> IO ()
+casadi__SymbolicOCP__setOde__1
+ :: SymbolicOCP -> String -> SX -> IO ()
+casadi__SymbolicOCP__setOde__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__setOde__1 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_setOde__1 :: SymbolicOCPClass a => a -> String -> SX -> IO ()
+symbolicOCP_setOde__1 x = casadi__SymbolicOCP__setOde__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__sortALG" c_casadi__SymbolicOCP__sortALG
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__sortALG
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__sortALG x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__sortALG errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_sortALG :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_sortALG x = casadi__SymbolicOCP__sortALG (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__sortDAE" c_casadi__SymbolicOCP__sortDAE
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__sortDAE
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__sortDAE x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__sortDAE errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_sortDAE :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_sortDAE x = casadi__SymbolicOCP__sortDAE (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__sortDependentParameters" c_casadi__SymbolicOCP__sortDependentParameters
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__sortDependentParameters
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__sortDependentParameters x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__sortDependentParameters errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_sortDependentParameters :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_sortDependentParameters x = casadi__SymbolicOCP__sortDependentParameters (castSymbolicOCP x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__SymbolicOCP__sortOutputs" c_casadi__SymbolicOCP__sortOutputs
+ :: Ptr (Ptr StdString) -> Ptr SymbolicOCP' -> IO ()
+casadi__SymbolicOCP__sortOutputs
+ :: SymbolicOCP -> IO ()
+casadi__SymbolicOCP__sortOutputs x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__SymbolicOCP__sortOutputs errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+symbolicOCP_sortOutputs :: SymbolicOCPClass a => a -> IO ()
+symbolicOCP_sortOutputs x = casadi__SymbolicOCP__sortOutputs (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)
+
diff --git a/Casadi/Core/Classes/Variable.hs b/Casadi/Core/Classes/Variable.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/Variable.hs
@@ -0,0 +1,185 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.Variable
+ (
+ Variable,
+ VariableClass(..),
+ variable,
+ variable_atTime__0,
+ variable_atTime__1,
+ variable_atTime__2,
+ variable_atTime__3,
+ variable_name,
+ variable_setName,
+ ) 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__Variable__CONSTRUCTOR" c_casadi__Variable__CONSTRUCTOR
+ :: Ptr (Ptr StdString) -> IO (Ptr Variable')
+casadi__Variable__CONSTRUCTOR
+ :: IO Variable
+casadi__Variable__CONSTRUCTOR =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Variable__CONSTRUCTOR errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+variable :: IO Variable
+variable = casadi__Variable__CONSTRUCTOR
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Variable__atTime__0" c_casadi__Variable__atTime__0
+ :: Ptr (Ptr StdString) -> Ptr Variable' -> CDouble -> IO (Ptr SXElement')
+casadi__Variable__atTime__0
+ :: Variable -> Double -> IO SXElement
+casadi__Variable__atTime__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Variable__atTime__0 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+variable_atTime__0 :: VariableClass a => a -> Double -> IO SXElement
+variable_atTime__0 x = casadi__Variable__atTime__0 (castVariable x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Variable__atTime__1" c_casadi__Variable__atTime__1
+ :: Ptr (Ptr StdString) -> Ptr Variable' -> CDouble -> CInt -> IO (Ptr SXElement')
+casadi__Variable__atTime__1
+ :: Variable -> Double -> Bool -> IO SXElement
+casadi__Variable__atTime__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Variable__atTime__1 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+variable_atTime__1 :: VariableClass a => a -> Double -> Bool -> IO SXElement
+variable_atTime__1 x = casadi__Variable__atTime__1 (castVariable x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Variable__atTime__2" c_casadi__Variable__atTime__2
+ :: Ptr (Ptr StdString) -> Ptr Variable' -> CDouble -> IO (Ptr SXElement')
+casadi__Variable__atTime__2
+ :: Variable -> Double -> IO SXElement
+casadi__Variable__atTime__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Variable__atTime__2 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+variable_atTime__2 :: VariableClass a => a -> Double -> IO SXElement
+variable_atTime__2 x = casadi__Variable__atTime__2 (castVariable x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Variable__atTime__3" c_casadi__Variable__atTime__3
+ :: Ptr (Ptr StdString) -> Ptr Variable' -> CDouble -> CInt -> IO (Ptr SXElement')
+casadi__Variable__atTime__3
+ :: Variable -> Double -> Bool -> IO SXElement
+casadi__Variable__atTime__3 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Variable__atTime__3 errStrPtrP x0' x1' x2'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+variable_atTime__3 :: VariableClass a => a -> Double -> Bool -> IO SXElement
+variable_atTime__3 x = casadi__Variable__atTime__3 (castVariable x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Variable__name" c_casadi__Variable__name
+ :: Ptr (Ptr StdString) -> Ptr Variable' -> IO (Ptr StdString)
+casadi__Variable__name
+ :: Variable -> IO String
+casadi__Variable__name x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Variable__name errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+variable_name :: VariableClass a => a -> IO String
+variable_name x = casadi__Variable__name (castVariable x)
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__Variable__setName" c_casadi__Variable__setName
+ :: Ptr (Ptr StdString) -> Ptr Variable' -> Ptr StdString -> IO ()
+casadi__Variable__setName
+ :: Variable -> String -> IO ()
+casadi__Variable__setName x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__Variable__setName errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+variable_setName :: VariableClass a => a -> String -> IO ()
+variable_setName x = casadi__Variable__setName (castVariable x)
+
diff --git a/Casadi/Core/Classes/XmlFile.hs b/Casadi/Core/Classes/XmlFile.hs
new file mode 100644
--- /dev/null
+++ b/Casadi/Core/Classes/XmlFile.hs
@@ -0,0 +1,115 @@
+{-# OPTIONS_GHC -Wall #-}
+{-# OPTIONS_GHC -fno-warn-unused-imports #-}
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+{-# Language ForeignFunctionInterface #-}
+{-# Language FlexibleInstances #-}
+{-# Language MultiParamTypeClasses #-}
+
+module Casadi.Core.Classes.XmlFile
+ (
+ XmlFile,
+ XmlFileClass(..),
+ xmlFile__0,
+ xmlFile__1,
+ xmlFile_doc,
+ xmlFile_loadPlugin,
+ ) 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__XmlFile__CONSTRUCTOR__0" c_casadi__XmlFile__CONSTRUCTOR__0
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr XmlFile')
+casadi__XmlFile__CONSTRUCTOR__0
+ :: String -> IO XmlFile
+casadi__XmlFile__CONSTRUCTOR__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__XmlFile__CONSTRUCTOR__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+xmlFile__0 :: String -> IO XmlFile
+xmlFile__0 = casadi__XmlFile__CONSTRUCTOR__0
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__XmlFile__CONSTRUCTOR__1" c_casadi__XmlFile__CONSTRUCTOR__1
+ :: Ptr (Ptr StdString) -> IO (Ptr XmlFile')
+casadi__XmlFile__CONSTRUCTOR__1
+ :: IO XmlFile
+casadi__XmlFile__CONSTRUCTOR__1 =
+
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__XmlFile__CONSTRUCTOR__1 errStrPtrP
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+xmlFile__1 :: IO XmlFile
+xmlFile__1 = casadi__XmlFile__CONSTRUCTOR__1
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__XmlFile__doc" c_casadi__XmlFile__doc
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO (Ptr StdString)
+casadi__XmlFile__doc
+ :: String -> IO String
+casadi__XmlFile__doc x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__XmlFile__doc errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+xmlFile_doc :: String -> IO String
+xmlFile_doc = casadi__XmlFile__doc
+
+
+-- direct wrapper
+foreign import ccall unsafe "casadi__XmlFile__loadPlugin" c_casadi__XmlFile__loadPlugin
+ :: Ptr (Ptr StdString) -> Ptr StdString -> IO ()
+casadi__XmlFile__loadPlugin
+ :: String -> IO ()
+casadi__XmlFile__loadPlugin x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_casadi__XmlFile__loadPlugin errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+-- classy wrapper
+xmlFile_loadPlugin :: String -> IO ()
+xmlFile_loadPlugin = casadi__XmlFile__loadPlugin
+
diff --git a/Casadi/Core/Data.hs b/Casadi/Core/Data.hs
--- a/Casadi/Core/Data.hs
+++ b/Casadi/Core/Data.hs
@@ -38,11108 +38,12680 @@
instance FunctorClass Callback where
castFunctor (Callback x) = Functor (castForeignPtr x)
-instance PrintableObjectClass Callback where
- castPrintableObject (Callback x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass Callback where
- castSharedObject (Callback x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Callback (Ptr Callback') where
- marshal (Callback x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Callback x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Callback"
- c_delete_casadi__Callback :: FunPtr (Ptr Callback' -> IO ())
-instance WrapReturn (Ptr Callback') Callback where
- wrapReturn = (fmap Callback) . (newForeignPtr c_delete_casadi__Callback)
-
-
--- raw decl
-data CasadiMeta'
--- data decl
-{-|
->Collects global CasADi meta information.
->
->Joris Gillis
->
->C++ includes: casadi_meta.hpp
--}
-newtype CasadiMeta = CasadiMeta (ForeignPtr CasadiMeta')
--- typeclass decl
-class CasadiMetaClass a where
- castCasadiMeta :: a -> CasadiMeta
-instance CasadiMetaClass CasadiMeta where
- castCasadiMeta = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal CasadiMeta (Ptr CasadiMeta') where
- marshal (CasadiMeta x) = return (unsafeForeignPtrToPtr x)
- marshalFree (CasadiMeta x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CasadiMeta"
- c_delete_casadi__CasadiMeta :: FunPtr (Ptr CasadiMeta' -> IO ())
-instance WrapReturn (Ptr CasadiMeta') CasadiMeta where
- wrapReturn = (fmap CasadiMeta) . (newForeignPtr c_delete_casadi__CasadiMeta)
-
-
--- raw decl
-data CasadiOptions'
--- data decl
-{-|
->Collects global CasADi options.
->
->Note to developers: use sparingly. Global options are - in general - a
->rather bad idea
->
->this class must never be instantiated. Access its static members directly
->Joris Gillis
->
->C++ includes: casadi_options.hpp
--}
-newtype CasadiOptions = CasadiOptions (ForeignPtr CasadiOptions')
--- typeclass decl
-class CasadiOptionsClass a where
- castCasadiOptions :: a -> CasadiOptions
-instance CasadiOptionsClass CasadiOptions where
- castCasadiOptions = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal CasadiOptions (Ptr CasadiOptions') where
- marshal (CasadiOptions x) = return (unsafeForeignPtrToPtr x)
- marshalFree (CasadiOptions x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CasadiOptions"
- c_delete_casadi__CasadiOptions :: FunPtr (Ptr CasadiOptions' -> IO ())
-instance WrapReturn (Ptr CasadiOptions') CasadiOptions where
- wrapReturn = (fmap CasadiOptions) . (newForeignPtr c_delete_casadi__CasadiOptions)
-
-
--- raw decl
-data ControlSimulator'
--- data decl
-{-|
->Piecewise Simulation class.
->
->A ControlSimulator can be seen as a chain of Simulators whereby some
->parameters change from one Simulator to the next.
->
->These changing parameters can typically be interpreted as "controls" in
->the context of dynamic optimization.
->
->We discriminate between the following time steps: Major time-steps. These
->are the time steps provided by the supplied grid. Controls are constant
->inbetween major time-steps Minor time-steps. These are time steps linearly
->interpolated from one major time-step to the next. The option 'nf' regulates
->how many minor time-steps are taken. Integration time-steps. Time steps
->that the supplied integrator might choose to integrate the continuous
->dynamics. They are not important what ControlSimulator is concerned. np
->Number of parameters nu Number of controls ns The number of major grid
->points, as supplied in the constructor nf The number of minor grid points
->per major interval
->
->Joris Gillis
->
->>Input scheme: casadi::ControlSimulatorInput (CONTROLSIMULATOR_NUM_IN = 3) [controlsimulatorIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| CONTROLSIMULATOR_X0 | x0 | Differential or |
->| | | algebraic state at t0 |
->| | | (dimension nx-by-1) . |
->+------------------------+------------------------+------------------------+
->| CONTROLSIMULATOR_P | p | Parameters that are |
->| | | fixed over the entire |
->| | | horizon (dimension np- |
->| | | by-1) . |
->+------------------------+------------------------+------------------------+
->| CONTROLSIMULATOR_U | u | Parameters that change |
->| | | over the integration |
->| | | intervals (dimension |
->| | | nu-by-(ns-1)) . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| control_endp | OT_BOOLEAN | false | Include a | casadi::Cont |
->| oint | | | control | rolSimulator |
->| | | | value at the | Internal |
->| | | | end of the | |
->| | | | simulation | |
->| | | | domain. Used | |
->| | | | for interpol | |
->| | | | ation. | |
->+--------------+--------------+--------------+--------------+--------------+
->| control_inte | OT_STRING | "none" | none|nearest | casadi::Cont |
->| rpolation | | | |linear | rolSimulator |
->| | | | | Internal |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| integrator | OT_STRING | GenericType( | An | casadi::Cont |
->| | | ) | integrator | rolSimulator |
->| | | | creator | Internal |
->| | | | function | |
->+--------------+--------------+--------------+--------------+--------------+
->| integrator_o | OT_DICTIONAR | GenericType( | Options to | casadi::Cont |
->| ptions | Y | ) | be passed to | rolSimulator |
->| | | | the | Internal |
->| | | | integrator | |
->+--------------+--------------+--------------+--------------+--------------+
->| minor_grid | OT_INTEGERVE | GenericType( | The local | casadi::Cont |
->| | CTOR | ) | grid used on | rolSimulator |
->| | | | each major | Internal |
->| | | | interval, | |
->| | | | with time | |
->| | | | normalized | |
->| | | | to 1. By | |
->| | | | default, | |
->| | | | option 'nf' | |
->| | | | is used to | |
->| | | | construct a | |
->| | | | linearly | |
->| | | | spaced grid. | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| nf | OT_INTEGER | 1 | Number of | casadi::Cont |
->| | | | minor | rolSimulator |
->| | | | grained | Internal |
->| | | | integration | |
->| | | | steps per | |
->| | | | major | |
->| | | | interval. | |
->| | | | nf>0 must | |
->| | | | hold. This | |
->| | | | option is | |
->| | | | not used | |
->| | | | when | |
->| | | | 'minor_grid' | |
->| | | | is provided. | |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| simulator_op | OT_DICTIONAR | GenericType( | Options to | casadi::Cont |
->| tions | Y | ) | be passed to | rolSimulator |
->| | | | the | Internal |
->| | | | simulator | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: control_simulator.hpp
--}
-newtype ControlSimulator = ControlSimulator (ForeignPtr ControlSimulator')
--- typeclass decl
-class ControlSimulatorClass a where
- castControlSimulator :: a -> ControlSimulator
-instance ControlSimulatorClass ControlSimulator where
- castControlSimulator = id
-
--- baseclass instances
-instance FunctionClass ControlSimulator where
- castFunction (ControlSimulator x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass ControlSimulator where
- castOptionsFunctionality (ControlSimulator x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass ControlSimulator where
- castPrintableObject (ControlSimulator x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass ControlSimulator where
- castSharedObject (ControlSimulator x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass ControlSimulator where
- castIOInterfaceFunction (ControlSimulator x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal ControlSimulator (Ptr ControlSimulator') where
- marshal (ControlSimulator x) = return (unsafeForeignPtrToPtr x)
- marshalFree (ControlSimulator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__ControlSimulator"
- c_delete_casadi__ControlSimulator :: FunPtr (Ptr ControlSimulator' -> IO ())
-instance WrapReturn (Ptr ControlSimulator') ControlSimulator where
- wrapReturn = (fmap ControlSimulator) . (newForeignPtr c_delete_casadi__ControlSimulator)
-
-
--- raw decl
-data CustomEvaluate'
--- data decl
-{-|
->CustomEvaluate.
->
->In C++, supply a CustomEvaluateCPtr function pointer
->
->In python, supply a callable, annotated with pyevaluate decorator
->
->C++ includes: functor.hpp
--}
-newtype CustomEvaluate = CustomEvaluate (ForeignPtr CustomEvaluate')
--- typeclass decl
-class CustomEvaluateClass a where
- castCustomEvaluate :: a -> CustomEvaluate
-instance CustomEvaluateClass CustomEvaluate where
- castCustomEvaluate = id
-
--- baseclass instances
-instance FunctorClass CustomEvaluate where
- castFunctor (CustomEvaluate x) = Functor (castForeignPtr x)
-
-instance PrintableObjectClass CustomEvaluate where
- castPrintableObject (CustomEvaluate x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass CustomEvaluate where
- castSharedObject (CustomEvaluate x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal CustomEvaluate (Ptr CustomEvaluate') where
- marshal (CustomEvaluate x) = return (unsafeForeignPtrToPtr x)
- marshalFree (CustomEvaluate x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CustomEvaluate"
- c_delete_casadi__CustomEvaluate :: FunPtr (Ptr CustomEvaluate' -> IO ())
-instance WrapReturn (Ptr CustomEvaluate') CustomEvaluate where
- wrapReturn = (fmap CustomEvaluate) . (newForeignPtr c_delete_casadi__CustomEvaluate)
-
-
--- raw decl
-data CustomFunction'
--- data decl
-{-|
->Interface to a custom function.
->
->Joel Andersson
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: custom_function.hpp
--}
-newtype CustomFunction = CustomFunction (ForeignPtr CustomFunction')
--- typeclass decl
-class CustomFunctionClass a where
- castCustomFunction :: a -> CustomFunction
-instance CustomFunctionClass CustomFunction where
- castCustomFunction = id
-
--- baseclass instances
-instance FunctionClass CustomFunction where
- castFunction (CustomFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass CustomFunction where
- castOptionsFunctionality (CustomFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass CustomFunction where
- castPrintableObject (CustomFunction x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass CustomFunction where
- castSharedObject (CustomFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass CustomFunction where
- castIOInterfaceFunction (CustomFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal CustomFunction (Ptr CustomFunction') where
- marshal (CustomFunction x) = return (unsafeForeignPtrToPtr x)
- marshalFree (CustomFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__CustomFunction"
- c_delete_casadi__CustomFunction :: FunPtr (Ptr CustomFunction' -> IO ())
-instance WrapReturn (Ptr CustomFunction') CustomFunction where
- wrapReturn = (fmap CustomFunction) . (newForeignPtr c_delete_casadi__CustomFunction)
-
-
--- raw decl
-data DMatrix'
--- data decl
-{-|
--}
-newtype DMatrix = DMatrix (ForeignPtr DMatrix')
--- typeclass decl
-class DMatrixClass a where
- castDMatrix :: a -> DMatrix
-instance DMatrixClass DMatrix where
- castDMatrix = id
-
--- baseclass instances
-instance PrintableObjectClass DMatrix where
- castPrintableObject (DMatrix x) = PrintableObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal DMatrix (Ptr DMatrix') where
- marshal (DMatrix x) = return (unsafeForeignPtrToPtr x)
- marshalFree (DMatrix x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DMatrix"
- c_delete_casadi__DMatrix :: FunPtr (Ptr DMatrix' -> IO ())
-instance WrapReturn (Ptr DMatrix') DMatrix where
- wrapReturn = (fmap DMatrix) . (newForeignPtr c_delete_casadi__DMatrix)
-
-
--- raw decl
-data DerivativeGenerator'
--- data decl
-{-|
->Derivative Generator Functor.
->
->In C++, supply a DerivativeGeneratorCPtr function pointer
->
->In python, supply a callable, annotated with derivativegenerator decorator
->
->C++ includes: functor.hpp
--}
-newtype DerivativeGenerator = DerivativeGenerator (ForeignPtr DerivativeGenerator')
--- typeclass decl
-class DerivativeGeneratorClass a where
- castDerivativeGenerator :: a -> DerivativeGenerator
-instance DerivativeGeneratorClass DerivativeGenerator where
- castDerivativeGenerator = id
-
--- baseclass instances
-instance FunctorClass DerivativeGenerator where
- castFunctor (DerivativeGenerator x) = Functor (castForeignPtr x)
-
-instance PrintableObjectClass DerivativeGenerator where
- castPrintableObject (DerivativeGenerator x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass DerivativeGenerator where
- castSharedObject (DerivativeGenerator x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal DerivativeGenerator (Ptr DerivativeGenerator') where
- marshal (DerivativeGenerator x) = return (unsafeForeignPtrToPtr x)
- marshalFree (DerivativeGenerator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__DerivativeGenerator"
- c_delete_casadi__DerivativeGenerator :: FunPtr (Ptr DerivativeGenerator' -> IO ())
-instance WrapReturn (Ptr DerivativeGenerator') DerivativeGenerator where
- wrapReturn = (fmap DerivativeGenerator) . (newForeignPtr c_delete_casadi__DerivativeGenerator)
-
-
--- raw decl
-data ExternalFunction'
--- data decl
-{-|
->Interface for a function that is not implemented by CasADi symbolics.
->
->Joel Andersson
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: external_function.hpp
--}
-newtype ExternalFunction = ExternalFunction (ForeignPtr ExternalFunction')
--- typeclass decl
-class ExternalFunctionClass a where
- castExternalFunction :: a -> ExternalFunction
-instance ExternalFunctionClass ExternalFunction where
- castExternalFunction = id
-
--- baseclass instances
-instance FunctionClass ExternalFunction where
- castFunction (ExternalFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass ExternalFunction where
- castOptionsFunctionality (ExternalFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass ExternalFunction where
- castPrintableObject (ExternalFunction x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass ExternalFunction where
- castSharedObject (ExternalFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass ExternalFunction where
- castIOInterfaceFunction (ExternalFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal ExternalFunction (Ptr ExternalFunction') where
- marshal (ExternalFunction x) = return (unsafeForeignPtrToPtr x)
- marshalFree (ExternalFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__ExternalFunction"
- c_delete_casadi__ExternalFunction :: FunPtr (Ptr ExternalFunction' -> IO ())
-instance WrapReturn (Ptr ExternalFunction') ExternalFunction where
- wrapReturn = (fmap ExternalFunction) . (newForeignPtr c_delete_casadi__ExternalFunction)
-
-
--- raw decl
-data Function'
--- data decl
-{-|
->General function.
->
->A general function $f$ in casadi can be multi-input, multi-output. Number of
->inputs: nin getNumInputs() Number of outputs: nout getNumOutputs() We can
->view this function as a being composed of a ( nin, nout) grid of single-
->input, single-output primitive functions. Each such primitive function $f_
->{i, j} \\\\forall i \\\\in [0, nin-1], j \\\\in [0, nout-1]$ can map as
->$\\\\mathbf {R}^{n, m}\\\\to\\\\mathbf{R}^{p, q}$, in which n, m, p, q can
->take different values for every (i, j) pair. When passing input, you
->specify which partition $i$ is active. You pass the numbers vectorized, as a
->vector of size $(n*m)$. When requesting output, you specify which partition
->$j$ is active. You get the numbers vectorized, as a vector of size $(p*q)$.
->To calculate Jacobians, you need to have $(m=1, q=1)$.
->
->Write the Jacobian as $J_ {i, j} = \\\\nabla f_{i, j} = \\\\frac
->{\\\\partial f_{i, j}(\\\\vec{x})}{\\\\partial \\\\vec{x}}$.
->
->Using $\\\\vec {v} \\\\in \\\\mathbf{R}^n$ as a forward seed: setFwdSeed(v,
->i) Retrieving $\\\\vec {s}_f \\\\in \\\\mathbf{R}^p$ from: getFwdSens(sf, j)
->Using $\\\\vec {w} \\\\in \\\\mathbf{R}^p$ as a forward seed: setAdjSeed(w,
->j) Retrieving $\\\\vec {s}_a \\\\in \\\\mathbf{R}^n $ from: getAdjSens(sa,
->i) We have the following relationships for function mapping from a row
->vector to a row vector:
->
->$ \\\\vec {s}_f = \\\\nabla f_{i, j} . \\\\vec{v}$ $ \\\\vec {s}_a =
->(\\\\nabla f_{i, j})^T . \\\\vec{w}$
->
->Some quantities in these formulas must be transposed: input col: transpose $
->\\\\vec {v} $ and $\\\\vec{s}_a$ output col: transpose $ \\\\vec {w} $ and
->$\\\\vec{s}_f$ NOTE: Functions are allowed to modify their input arguments
->when evaluating: implicitFunction, IDAS solver Further releases may disallow
->this.
->
->Joel Andersson
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->>List of available monitors
->
->+---------+--------------------------+
->| Id | Used in |
->+=========+==========================+
->| inputs | casadi::FunctionInternal |
->+---------+--------------------------+
->| outputs | casadi::FunctionInternal |
->+---------+--------------------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: function.hpp
--}
-newtype Function = Function (ForeignPtr Function')
--- typeclass decl
-class FunctionClass a where
- castFunction :: a -> Function
-instance FunctionClass Function where
- castFunction = id
-
--- baseclass instances
-instance OptionsFunctionalityClass Function where
- castOptionsFunctionality (Function x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass Function where
- castPrintableObject (Function x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass Function where
- castSharedObject (Function x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Function where
- castIOInterfaceFunction (Function x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Function (Ptr Function') where
- marshal (Function x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Function x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Function"
- c_delete_casadi__Function :: FunPtr (Ptr Function' -> IO ())
-instance WrapReturn (Ptr Function') Function where
- wrapReturn = (fmap Function) . (newForeignPtr c_delete_casadi__Function)
-
-
--- raw decl
-data Functor'
--- data decl
-{-|
->Functor.
->
->Joris Gillis
->
->C++ includes: functor.hpp
--}
-newtype Functor = Functor (ForeignPtr Functor')
--- typeclass decl
-class FunctorClass a where
- castFunctor :: a -> Functor
-instance FunctorClass Functor where
- castFunctor = id
-
--- baseclass instances
-instance PrintableObjectClass Functor where
- castPrintableObject (Functor x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass Functor where
- castSharedObject (Functor x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Functor (Ptr Functor') where
- marshal (Functor x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Functor x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Functor"
- c_delete_casadi__Functor :: FunPtr (Ptr Functor' -> IO ())
-instance WrapReturn (Ptr Functor') Functor where
- wrapReturn = (fmap Functor) . (newForeignPtr c_delete_casadi__Functor)
-
-
--- raw decl
-data GenericType'
--- data decl
-{-|
->Generic data type.
->
->Joel Andersson
->
->C++ includes: generic_type.hpp
--}
-newtype GenericType = GenericType (ForeignPtr GenericType')
--- typeclass decl
-class GenericTypeClass a where
- castGenericType :: a -> GenericType
-instance GenericTypeClass GenericType where
- castGenericType = id
-
--- baseclass instances
-instance PrintableObjectClass GenericType where
- castPrintableObject (GenericType x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass GenericType where
- castSharedObject (GenericType x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal GenericType (Ptr GenericType') where
- marshal (GenericType x) = return (unsafeForeignPtrToPtr x)
- marshalFree (GenericType x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__GenericType"
- c_delete_casadi__GenericType :: FunPtr (Ptr GenericType' -> IO ())
-instance WrapReturn (Ptr GenericType') GenericType where
- wrapReturn = (fmap GenericType) . (newForeignPtr c_delete_casadi__GenericType)
-
-
--- raw decl
-data HomotopyNlpSolver'
--- data decl
-{-|
->Base class for Homotopy NLP Solvers.
->
->Solves the following parametric nonlinear program (NLP):
->
->::
->
-> min F(x, p, tau)
-> x
->
-> subject to
-> LBX <= x <= UBX
-> LBG <= G(x, p) <= UBG
-> p == P
->
-> nx: number of decision variables
-> ng: number of constraints
-> np: number of parameters
->
->
->
->
->In a homotopy from tau = 0 to tau = 1.
->
->General information
->===================
->
->
->
->>Input scheme: casadi::NlpSolverInput (NLP_SOLVER_NUM_IN = 8) [nlpSolverIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| NLP_SOLVER_X0 | x0 | Decision variables, |
->| | | initial guess (nx x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_P | p | Value of fixed |
->| | | parameters (np x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LBX | lbx | Decision variables |
->| | | lower bound (nx x 1), |
->| | | default -inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_UBX | ubx | Decision variables |
->| | | upper bound (nx x 1), |
->| | | default +inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LBG | lbg | Constraints lower |
->| | | bound (ng x 1), |
->| | | default -inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_UBG | ubg | Constraints upper |
->| | | bound (ng x 1), |
->| | | default +inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_X0 | lam_x0 | Lagrange multipliers |
->| | | for bounds on X, |
->| | | initial guess (nx x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_G0 | lam_g0 | Lagrange multipliers |
->| | | for bounds on G, |
->| | | initial guess (ng x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::NlpSolverOutput (NLP_SOLVER_NUM_OUT = 6) [nlpSolverOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| NLP_SOLVER_X | x | Decision variables at |
->| | | the optimal solution |
->| | | (nx x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_F | f | Cost function value at |
->| | | the optimal solution |
->| | | (1 x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_G | g | Constraints function |
->| | | at the optimal |
->| | | solution (ng x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_X | lam_x | Lagrange multipliers |
->| | | for bounds on X at the |
->| | | solution (nx x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_G | lam_g | Lagrange multipliers |
->| | | for bounds on G at the |
->| | | solution (ng x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_P | lam_p | Lagrange multipliers |
->| | | for bounds on P at the |
->| | | solution (np x 1) . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| expand | OT_BOOLEAN | false | Expand the | casadi::Homo |
->| | | | NLP function | topyNLPInter |
->| | | | in terms of | nal |
->| | | | scalar | |
->| | | | operations, | |
->| | | | i.e. MX->SX | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- simple
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->HomotopyNlpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->simple
->------
->
->
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| nlp_solver | OT_STRING | GenericType() | The NLP solver |
->| | | | to be used by |
->| | | | the Homotopy |
->| | | | solver |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_solver_opti | OT_DICTIONARY | GenericType() | Options to be |
->| ons | | | passed to the |
->| | | | Homotopy solver |
->+-----------------+-----------------+-----------------+-----------------+
->| num_steps | OT_INTEGER | 10 | Take this many |
->| | | | steps to go |
->| | | | from tau=0 to |
->| | | | tau=1. |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joris Gillis
->Diagrams
->--------
->
->
->
->C++ includes: homotopy_nlp_solver.hpp
--}
-newtype HomotopyNlpSolver = HomotopyNlpSolver (ForeignPtr HomotopyNlpSolver')
--- typeclass decl
-class HomotopyNlpSolverClass a where
- castHomotopyNlpSolver :: a -> HomotopyNlpSolver
-instance HomotopyNlpSolverClass HomotopyNlpSolver where
- castHomotopyNlpSolver = id
-
--- baseclass instances
-instance FunctionClass HomotopyNlpSolver where
- castFunction (HomotopyNlpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass HomotopyNlpSolver where
- castOptionsFunctionality (HomotopyNlpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass HomotopyNlpSolver where
- castPrintableObject (HomotopyNlpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass HomotopyNlpSolver where
- castSharedObject (HomotopyNlpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass HomotopyNlpSolver where
- castIOInterfaceFunction (HomotopyNlpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal HomotopyNlpSolver (Ptr HomotopyNlpSolver') where
- marshal (HomotopyNlpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (HomotopyNlpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__HomotopyNlpSolver"
- c_delete_casadi__HomotopyNlpSolver :: FunPtr (Ptr HomotopyNlpSolver' -> IO ())
-instance WrapReturn (Ptr HomotopyNlpSolver') HomotopyNlpSolver where
- wrapReturn = (fmap HomotopyNlpSolver) . (newForeignPtr c_delete_casadi__HomotopyNlpSolver)
-
-
--- raw decl
-data IMatrix'
--- data decl
-{-|
--}
-newtype IMatrix = IMatrix (ForeignPtr IMatrix')
--- typeclass decl
-class IMatrixClass a where
- castIMatrix :: a -> IMatrix
-instance IMatrixClass IMatrix where
- castIMatrix = id
-
--- baseclass instances
-instance PrintableObjectClass IMatrix where
- castPrintableObject (IMatrix x) = PrintableObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal IMatrix (Ptr IMatrix') where
- marshal (IMatrix x) = return (unsafeForeignPtrToPtr x)
- marshalFree (IMatrix x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__IMatrix"
- c_delete_casadi__IMatrix :: FunPtr (Ptr IMatrix' -> IO ())
-instance WrapReturn (Ptr IMatrix') IMatrix where
- wrapReturn = (fmap IMatrix) . (newForeignPtr c_delete_casadi__IMatrix)
-
-
--- raw decl
-data IOScheme'
--- data decl
-{-|
->Class with mapping between names and indices.
->
->Joris Gillis
->
->C++ includes: io_scheme.hpp
--}
-newtype IOScheme = IOScheme (ForeignPtr IOScheme')
--- typeclass decl
-class IOSchemeClass a where
- castIOScheme :: a -> IOScheme
-instance IOSchemeClass IOScheme where
- castIOScheme = id
-
--- baseclass instances
-instance PrintableObjectClass IOScheme where
- castPrintableObject (IOScheme x) = PrintableObject (castForeignPtr x)
-
-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
-{-|
->Abstract base class for the implicit function classes.
->
->The equation:
->
->F(z, x1, x2, ..., xn) == 0
->
->where d_F/dz is invertible, implicitly defines the equation:
->
->z := G(x1, x2, ..., xn)
->
->F should be an Function mapping from (n+1) inputs to m outputs. The first
->output is the residual that should be zero.
->
->ImplicitFunction (G) is an Function mapping from n inputs to m outputs. n
->may be zero. The first output is the solved for z.
->
->You can provide an initial guess for z by setting output(0) of
->ImplicitFunction.
->
->General information
->===================
->
->
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| constraints | OT_INTEGERVE | GenericType( | Constrain | casadi::Impl |
->| | CTOR | ) | the | icitFunction |
->| | | | unknowns. 0 | Internal |
->| | | | (default): | |
->| | | | no | |
->| | | | constraint | |
->| | | | on ui, 1: ui | |
->| | | | >= 0.0, -1: | |
->| | | | ui <= 0.0, | |
->| | | | 2: ui > 0.0, | |
->| | | | -2: ui < | |
->| | | | 0.0. | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| implicit_inp | OT_INTEGER | 0 | Index of the | casadi::Impl |
->| ut | | | input that | icitFunction |
->| | | | corresponds | Internal |
->| | | | to the | |
->| | | | actual root- | |
->| | | | finding | |
->+--------------+--------------+--------------+--------------+--------------+
->| implicit_out | OT_INTEGER | 0 | Index of the | casadi::Impl |
->| put | | | output that | icitFunction |
->| | | | corresponds | Internal |
->| | | | to the | |
->| | | | actual root- | |
->| | | | finding | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| linear_solve | OT_STRING | GenericType( | User-defined | casadi::Impl |
->| r | | ) | linear | icitFunction |
->| | | | solver | Internal |
->| | | | class. | |
->| | | | Needed for s | |
->| | | | ensitivities | |
->| | | | . | |
->+--------------+--------------+--------------+--------------+--------------+
->| linear_solve | OT_DICTIONAR | GenericType( | Options to | casadi::Impl |
->| r_options | Y | ) | be passed to | icitFunction |
->| | | | the linear | Internal |
->| | | | solver. | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- kinsol
->
->- newton
->
->- nlp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->ImplicitFunction.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->kinsol
->------
->
->
->
->KINSOL interface from the Sundials suite
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| abstol | OT_REAL | 0.000 | Stopping |
->| | | | criterion |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| disable_interna | OT_BOOLEAN | false | Disable KINSOL |
->| l_warnings | | | internal |
->| | | | warning |
->| | | | messages |
->+-----------------+-----------------+-----------------+-----------------+
->| exact_jacobian | OT_BOOLEAN | true | |
->+-----------------+-----------------+-----------------+-----------------+
->| f_scale | OT_REALVECTOR | | |
->+-----------------+-----------------+-----------------+-----------------+
->| iterative_solve | OT_STRING | "gmres" | gmres|bcgstab|t |
->| r | | | fqmr |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_t | OT_STRING | "dense" | dense|banded|it |
->| ype | | | erative|user_de |
->| | | | fined |
->+-----------------+-----------------+-----------------+-----------------+
->| lower_bandwidth | OT_INTEGER | | |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter | OT_INTEGER | 0 | Maximum number |
->| | | | of Newton |
->| | | | iterations. |
->| | | | Putting 0 sets |
->| | | | the default |
->| | | | value of |
->| | | | KinSol. |
->+-----------------+-----------------+-----------------+-----------------+
->| max_krylov | OT_INTEGER | 0 | |
->+-----------------+-----------------+-----------------+-----------------+
->| pretype | OT_STRING | "none" | (none|left|righ |
->| | | | t|both) |
->+-----------------+-----------------+-----------------+-----------------+
->| strategy | OT_STRING | "none" | Globalization |
->| | | | strategy (none| |
->| | | | linesearch) |
->+-----------------+-----------------+-----------------+-----------------+
->| u_scale | OT_REALVECTOR | | |
->+-----------------+-----------------+-----------------+-----------------+
->| upper_bandwidth | OT_INTEGER | | |
->+-----------------+-----------------+-----------------+-----------------+
->| use_preconditio | OT_BOOLEAN | false | precondition an |
->| ner | | | iterative |
->| | | | solver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-----------+
->| Id |
->+===========+
->| eval_djac |
->+-----------+
->| eval_f |
->+-----------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->newton
->------
->
->
->
->Implements simple newton iterations to solve an implicit function.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| abstol | OT_REAL | 0.000 | Stopping |
->| | | | criterion |
->| | | | tolerance on |
->| | | | max(|F|) |
->+-----------------+-----------------+-----------------+-----------------+
->| abstolStep | OT_REAL | 0.000 | Stopping |
->| | | | criterion |
->| | | | tolerance on |
->| | | | step size |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter | OT_INTEGER | 1000 | Maximum number |
->| | | | of Newton |
->| | | | iterations to |
->| | | | perform before |
->| | | | returning. |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+----------+
->| Id |
->+==========+
->| F |
->+----------+
->| J |
->+----------+
->| normF |
->+----------+
->| step |
->+----------+
->| stepsize |
->+----------+
->
->>List of available stats
->
->+---------------+
->| Id |
->+===============+
->| iter |
->+---------------+
->| return_status |
->+---------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->nlp
->---
->
->
->
->Use an NlpSolver as ImplicitFunction solver
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| nlp_solver | OT_STRING | GenericType() | The NlpSolver |
->| | | | used to solve |
->| | | | the implicit |
->| | | | system. |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_solver_opti | OT_DICTIONARY | GenericType() | Options to be |
->| ons | | | passed to the |
->| | | | NlpSolver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+------------------+
->| Id |
->+==================+
->| nlp_solver_stats |
->+------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: implicit_function.hpp
--}
-newtype ImplicitFunction = ImplicitFunction (ForeignPtr ImplicitFunction')
--- typeclass decl
-class ImplicitFunctionClass a where
- castImplicitFunction :: a -> ImplicitFunction
-instance ImplicitFunctionClass ImplicitFunction where
- castImplicitFunction = id
-
--- baseclass instances
-instance FunctionClass ImplicitFunction where
- castFunction (ImplicitFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass ImplicitFunction where
- castOptionsFunctionality (ImplicitFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass ImplicitFunction where
- castPrintableObject (ImplicitFunction x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass ImplicitFunction where
- castSharedObject (ImplicitFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass ImplicitFunction where
- castIOInterfaceFunction (ImplicitFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal ImplicitFunction (Ptr ImplicitFunction') where
- marshal (ImplicitFunction x) = return (unsafeForeignPtrToPtr x)
- marshalFree (ImplicitFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__ImplicitFunction"
- c_delete_casadi__ImplicitFunction :: FunPtr (Ptr ImplicitFunction' -> IO ())
-instance WrapReturn (Ptr ImplicitFunction') ImplicitFunction where
- wrapReturn = (fmap ImplicitFunction) . (newForeignPtr c_delete_casadi__ImplicitFunction)
-
-
--- raw decl
-data Integrator'
--- data decl
-{-|
->Base class for integrators.
->
->Integrator abstract base class
->
->Solves an initial value problem (IVP) coupled to a terminal value problem
->with differential equation given as an implicit ODE coupled to an algebraic
->equation and a set of quadratures:
->
->::
->
-> Initial conditions at t=t0
-> x(t0) = x0
-> q(t0) = 0
->
-> Forward integration from t=t0 to t=tf
-> der(x) = function(x, z, p, t) Forward ODE
-> 0 = fz(x, z, p, t) Forward algebraic equations
-> der(q) = fq(x, z, p, t) Forward quadratures
->
-> Terminal conditions at t=tf
-> rx(tf) = rx0
-> rq(tf) = 0
->
-> Backward integration from t=tf to t=t0
-> der(rx) = gx(rx, rz, rp, x, z, p, t) Backward ODE
-> 0 = gz(rx, rz, rp, x, z, p, t) Backward algebraic equations
-> der(rq) = gq(rx, rz, rp, x, z, p, t) Backward quadratures
->
-> where we assume that both the forward and backwards integrations are index-1
-> (i.e. dfz/dz, dgz/drz are invertible) and furthermore that
-> gx, gz and gq have a linear dependency on rx, rz and rp.
->
->
->
->The Integrator class provides some additional functionality, such as getting
->the value of the state and/or sensitivities at certain time points.
->
->General information
->===================
->
->
->
->>Input scheme: casadi::IntegratorInput (INTEGRATOR_NUM_IN = 6) [integratorIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| INTEGRATOR_X0 | x0 | Differential state at |
->| | | the initial time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_P | p | Parameters . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_Z0 | z0 | Initial guess for the |
->| | | algebraic variable . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RX0 | rx0 | Backward differential |
->| | | state at the final |
->| | | time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RP | rp | Backward parameter |
->| | | vector . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RZ0 | rz0 | Initial guess for the |
->| | | backwards algebraic |
->| | | variable . |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::IntegratorOutput (INTEGRATOR_NUM_OUT = 6) [integratorOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| INTEGRATOR_XF | xf | Differential state at |
->| | | the final time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_QF | qf | Quadrature state at |
->| | | the final time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_ZF | zf | Algebraic variable at |
->| | | the final time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RXF | rxf | Backward differential |
->| | | state at the initial |
->| | | time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RQF | rqf | Backward quadrature |
->| | | state at the initial |
->| | | time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RZF | rzf | Backward algebraic |
->| | | variable at the |
->| | | initial time . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| augmented_op | OT_DICTIONAR | GenericType( | Options to | casadi::Inte |
->| tions | Y | ) | be passed | gratorIntern |
->| | | | down to the | al |
->| | | | augmented | |
->| | | | integrator, | |
->| | | | if one is | |
->| | | | constructed. | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| expand_augme | OT_BOOLEAN | true | If DAE | casadi::Inte |
->| nted | | | callback | gratorIntern |
->| | | | functions | al |
->| | | | are | |
->| | | | SXFunction , | |
->| | | | have | |
->| | | | augmented | |
->| | | | DAE callback | |
->| | | | function | |
->| | | | also be | |
->| | | | SXFunction . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| print_stats | OT_BOOLEAN | false | Print out | casadi::Inte |
->| | | | statistics | gratorIntern |
->| | | | after | al |
->| | | | integration | |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| t0 | OT_REAL | 0 | Beginning of | casadi::Inte |
->| | | | the time | gratorIntern |
->| | | | horizon | al |
->+--------------+--------------+--------------+--------------+--------------+
->| tf | OT_REAL | 1 | End of the | casadi::Inte |
->| | | | time horizon | gratorIntern |
->| | | | | al |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- cvodes
->
->- idas
->
->- collocation
->
->- oldcollocation
->
->- rk
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->Integrator.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->cvodes
->------
->
->
->
->Interface to CVodes from the Sundials suite.
->
->A call to evaluate will integrate to the end.
->
->You can retrieve the entire state trajectory as follows, after the evaluate
->call: Call reset. Then call integrate(t_i) and getOuput for a series of
->times t_i.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| abstol | OT_REAL | 0.000 | Absolute |
->| | | | tolerence for |
->| | | | the IVP |
->| | | | solution |
->+-----------------+-----------------+-----------------+-----------------+
->| abstolB | OT_REAL | GenericType() | Absolute |
->| | | | tolerence for |
->| | | | the adjoint |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to abstol] |
->+-----------------+-----------------+-----------------+-----------------+
->| disable_interna | OT_BOOLEAN | false | Disable CVodes |
->| l_warnings | | | internal |
->| | | | warning |
->| | | | messages |
->+-----------------+-----------------+-----------------+-----------------+
->| exact_jacobian | OT_BOOLEAN | true | Use exact |
->| | | | Jacobian |
->| | | | information for |
->| | | | the forward |
->| | | | integration |
->+-----------------+-----------------+-----------------+-----------------+
->| exact_jacobianB | OT_BOOLEAN | GenericType() | Use exact |
->| | | | Jacobian |
->| | | | information for |
->| | | | the backward |
->| | | | integration |
->| | | | [default: equal |
->| | | | to |
->| | | | exact_jacobian] |
->+-----------------+-----------------+-----------------+-----------------+
->| finite_differen | OT_BOOLEAN | false | Use finite |
->| ce_fsens | | | differences to |
->| | | | approximate the |
->| | | | forward |
->| | | | sensitivity |
->| | | | equations (if |
->| | | | AD is not |
->| | | | available) |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_abstol | OT_REAL | GenericType() | Absolute |
->| | | | tolerence for |
->| | | | the forward |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to abstol] |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_all_at_on | OT_BOOLEAN | true | Calculate all |
->| ce | | | right hand |
->| | | | sides of the |
->| | | | sensitivity |
->| | | | equations at |
->| | | | once |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_err_con | OT_BOOLEAN | true | include the |
->| | | | forward |
->| | | | sensitivities |
->| | | | in all error |
->| | | | controls |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_reltol | OT_REAL | GenericType() | Relative |
->| | | | tolerence for |
->| | | | the forward |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to reltol] |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_scaling_f | OT_REALVECTOR | GenericType() | Scaling factor |
->| actors | | | for the |
->| | | | components if |
->| | | | finite |
->| | | | differences is |
->| | | | used |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_sensitivi | OT_INTEGERVECTO | GenericType() | Specifies which |
->| y_parameters | R | | components will |
->| | | | be used when |
->| | | | estimating the |
->| | | | sensitivity |
->| | | | equations |
->+-----------------+-----------------+-----------------+-----------------+
->| interpolation_t | OT_STRING | "hermite" | Type of |
->| ype | | | interpolation |
->| | | | for the adjoint |
->| | | | sensitivities ( |
->| | | | hermite|polynom |
->| | | | ial) |
->+-----------------+-----------------+-----------------+-----------------+
->| iterative_solve | OT_STRING | "gmres" | (gmres|bcgstab| |
->| r | | | tfqmr) |
->+-----------------+-----------------+-----------------+-----------------+
->| iterative_solve | OT_STRING | GenericType() | (gmres|bcgstab| |
->| rB | | | tfqmr) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_multiste | OT_STRING | "bdf" | Integrator |
->| p_method | | | scheme |
->| | | | (bdf|adams) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver | OT_STRING | GenericType() | A custom linear |
->| | | | solver creator |
->| | | | function |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solverB | OT_STRING | GenericType() | A custom linear |
->| | | | solver creator |
->| | | | function for |
->| | | | backwards |
->| | | | integration |
->| | | | [default: equal |
->| | | | to |
->| | | | linear_solver] |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
->| ptions | | | passed to the |
->| | | | linear solver |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
->| ptionsB | | | passed to the |
->| | | | linear solver |
->| | | | for backwards |
->| | | | integration |
->| | | | [default: equal |
->| | | | to linear_solve |
->| | | | r_options] |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_t | OT_STRING | "dense" | (user_defined|d |
->| ype | | | ense|banded|ite |
->| | | | rative) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_t | OT_STRING | GenericType() | (user_defined|d |
->| ypeB | | | ense|banded|ite |
->| | | | rative) |
->+-----------------+-----------------+-----------------+-----------------+
->| lower_bandwidth | OT_INTEGER | GenericType() | Lower band- |
->| | | | width of banded |
->| | | | Jacobian |
->| | | | (estimations) |
->+-----------------+-----------------+-----------------+-----------------+
->| lower_bandwidth | OT_INTEGER | GenericType() | lower band- |
->| B | | | width of banded |
->| | | | jacobians for |
->| | | | backward |
->| | | | integration |
->| | | | [default: equal |
->| | | | to lower_bandwi |
->| | | | dth] |
->+-----------------+-----------------+-----------------+-----------------+
->| max_krylov | OT_INTEGER | 10 | Maximum Krylov |
->| | | | subspace size |
->+-----------------+-----------------+-----------------+-----------------+
->| max_krylovB | OT_INTEGER | GenericType() | Maximum krylov |
->| | | | subspace size |
->+-----------------+-----------------+-----------------+-----------------+
->| max_multistep_o | OT_INTEGER | 5 | |
->| rder | | | |
->+-----------------+-----------------+-----------------+-----------------+
->| max_num_steps | OT_INTEGER | 10000 | Maximum number |
->| | | | of integrator |
->| | | | steps |
->+-----------------+-----------------+-----------------+-----------------+
->| nonlinear_solve | OT_STRING | "newton" | (newton|functio |
->| r_iteration | | | nal) |
->+-----------------+-----------------+-----------------+-----------------+
->| pretype | OT_STRING | "none" | (none|left|righ |
->| | | | t|both) |
->+-----------------+-----------------+-----------------+-----------------+
->| pretypeB | OT_STRING | GenericType() | (none|left|righ |
->| | | | t|both) |
->+-----------------+-----------------+-----------------+-----------------+
->| quad_err_con | OT_BOOLEAN | false | Should the |
->| | | | quadratures |
->| | | | affect the step |
->| | | | size control |
->+-----------------+-----------------+-----------------+-----------------+
->| reltol | OT_REAL | 0.000 | Relative |
->| | | | tolerence for |
->| | | | the IVP |
->| | | | solution |
->+-----------------+-----------------+-----------------+-----------------+
->| reltolB | OT_REAL | GenericType() | Relative |
->| | | | tolerence for |
->| | | | the adjoint |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to reltol] |
->+-----------------+-----------------+-----------------+-----------------+
->| sensitivity_met | OT_STRING | "simultaneous" | (simultaneous|s |
->| hod | | | taggered) |
->+-----------------+-----------------+-----------------+-----------------+
->| steps_per_check | OT_INTEGER | 20 | Number of steps |
->| point | | | between two |
->| | | | consecutive |
->| | | | checkpoints |
->+-----------------+-----------------+-----------------+-----------------+
->| stop_at_end | OT_BOOLEAN | true | Stop the |
->| | | | integrator at |
->| | | | the end of the |
->| | | | interval |
->+-----------------+-----------------+-----------------+-----------------+
->| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
->| | | | width of banded |
->| | | | Jacobian |
->| | | | (estimations) |
->+-----------------+-----------------+-----------------+-----------------+
->| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
->| B | | | width of banded |
->| | | | jacobians for |
->| | | | backward |
->| | | | integration |
->| | | | [default: equal |
->| | | | to upper_bandwi |
->| | | | dth] |
->+-----------------+-----------------+-----------------+-----------------+
->| use_preconditio | OT_BOOLEAN | false | Precondition an |
->| ner | | | iterative |
->| | | | solver |
->+-----------------+-----------------+-----------------+-----------------+
->| use_preconditio | OT_BOOLEAN | GenericType() | Precondition an |
->| nerB | | | iterative |
->| | | | solver for the |
->| | | | backwards |
->| | | | problem |
->| | | | [default: equal |
->| | | | to use_precondi |
->| | | | tioner] |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+---------+
->| Id |
->+=========+
->| djacB |
->+---------+
->| psetupB |
->+---------+
->| res |
->+---------+
->| resB |
->+---------+
->| resQB |
->+---------+
->| reset |
->+---------+
->
->>List of available stats
->
->+-------------+
->| Id |
->+=============+
->| nlinsetups |
->+-------------+
->| nlinsetupsB |
->+-------------+
->| nsteps |
->+-------------+
->| nstepsB |
->+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->idas
->----
->
->
->
->Interface to IDAS from the Sundials suite.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| abstol | OT_REAL | 0.000 | Absolute |
->| | | | tolerence for |
->| | | | the IVP |
->| | | | solution |
->+-----------------+-----------------+-----------------+-----------------+
->| abstolB | OT_REAL | GenericType() | Absolute |
->| | | | tolerence for |
->| | | | the adjoint |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to abstol] |
->+-----------------+-----------------+-----------------+-----------------+
->| abstolv | OT_REALVECTOR | | |
->+-----------------+-----------------+-----------------+-----------------+
->| calc_ic | OT_BOOLEAN | true | Use IDACalcIC |
->| | | | to get |
->| | | | consistent |
->| | | | initial |
->| | | | conditions. |
->+-----------------+-----------------+-----------------+-----------------+
->| calc_icB | OT_BOOLEAN | GenericType() | Use IDACalcIC |
->| | | | to get |
->| | | | consistent |
->| | | | initial |
->| | | | conditions for |
->| | | | backwards |
->| | | | system |
->| | | | [default: equal |
->| | | | to calc_ic]. |
->+-----------------+-----------------+-----------------+-----------------+
->| cj_scaling | OT_BOOLEAN | false | IDAS scaling on |
->| | | | cj for the |
->| | | | user-defined |
->| | | | linear solver |
->| | | | module |
->+-----------------+-----------------+-----------------+-----------------+
->| disable_interna | OT_BOOLEAN | false | Disable IDAS |
->| l_warnings | | | internal |
->| | | | warning |
->| | | | messages |
->+-----------------+-----------------+-----------------+-----------------+
->| exact_jacobian | OT_BOOLEAN | true | Use exact |
->| | | | Jacobian |
->| | | | information for |
->| | | | the forward |
->| | | | integration |
->+-----------------+-----------------+-----------------+-----------------+
->| exact_jacobianB | OT_BOOLEAN | GenericType() | Use exact |
->| | | | Jacobian |
->| | | | information for |
->| | | | the backward |
->| | | | integration |
->| | | | [default: equal |
->| | | | to |
->| | | | exact_jacobian] |
->+-----------------+-----------------+-----------------+-----------------+
->| extra_fsens_cal | OT_BOOLEAN | false | Call calc ic an |
->| c_ic | | | extra time, |
->| | | | with fsens=0 |
->+-----------------+-----------------+-----------------+-----------------+
->| finite_differen | OT_BOOLEAN | false | Use finite |
->| ce_fsens | | | differences to |
->| | | | approximate the |
->| | | | forward |
->| | | | sensitivity |
->| | | | equations (if |
->| | | | AD is not |
->| | | | available) |
->+-----------------+-----------------+-----------------+-----------------+
->| first_time | OT_REAL | GenericType() | First requested |
->| | | | time as a |
->| | | | fraction of the |
->| | | | time interval |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_abstol | OT_REAL | GenericType() | Absolute |
->| | | | tolerence for |
->| | | | the forward |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to abstol] |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_abstolv | OT_REALVECTOR | | |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_err_con | OT_BOOLEAN | true | include the |
->| | | | forward |
->| | | | sensitivities |
->| | | | in all error |
->| | | | controls |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_reltol | OT_REAL | GenericType() | Relative |
->| | | | tolerence for |
->| | | | the forward |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to reltol] |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_scaling_f | OT_REALVECTOR | GenericType() | Scaling factor |
->| actors | | | for the |
->| | | | components if |
->| | | | finite |
->| | | | differences is |
->| | | | used |
->+-----------------+-----------------+-----------------+-----------------+
->| fsens_sensitivi | OT_INTEGERVECTO | GenericType() | Specifies which |
->| y_parameters | R | | components will |
->| | | | be used when |
->| | | | estimating the |
->| | | | sensitivity |
->| | | | equations |
->+-----------------+-----------------+-----------------+-----------------+
->| init_xdot | OT_REALVECTOR | GenericType() | Initial values |
->| | | | for the state |
->| | | | derivatives |
->+-----------------+-----------------+-----------------+-----------------+
->| interpolation_t | OT_STRING | "hermite" | Type of |
->| ype | | | interpolation |
->| | | | for the adjoint |
->| | | | sensitivities ( |
->| | | | hermite|polynom |
->| | | | ial) |
->+-----------------+-----------------+-----------------+-----------------+
->| iterative_solve | OT_STRING | "gmres" | (gmres|bcgstab| |
->| r | | | tfqmr) |
->+-----------------+-----------------+-----------------+-----------------+
->| iterative_solve | OT_STRING | GenericType() | (gmres|bcgstab| |
->| rB | | | tfqmr) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver | OT_STRING | GenericType() | A custom linear |
->| | | | solver creator |
->| | | | function |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solverB | OT_STRING | GenericType() | A custom linear |
->| | | | solver creator |
->| | | | function for |
->| | | | backwards |
->| | | | integration |
->| | | | [default: equal |
->| | | | to |
->| | | | linear_solver] |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
->| ptions | | | passed to the |
->| | | | linear solver |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
->| ptionsB | | | passed to the |
->| | | | linear solver |
->| | | | for backwards |
->| | | | integration |
->| | | | [default: equal |
->| | | | to linear_solve |
->| | | | r_options] |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_t | OT_STRING | "dense" | (user_defined|d |
->| ype | | | ense|banded|ite |
->| | | | rative) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver_t | OT_STRING | GenericType() | (user_defined|d |
->| ypeB | | | ense|banded|ite |
->| | | | rative) |
->+-----------------+-----------------+-----------------+-----------------+
->| lower_bandwidth | OT_INTEGER | GenericType() | Lower band- |
->| | | | width of banded |
->| | | | Jacobian |
->| | | | (estimations) |
->+-----------------+-----------------+-----------------+-----------------+
->| lower_bandwidth | OT_INTEGER | GenericType() | lower band- |
->| B | | | width of banded |
->| | | | jacobians for |
->| | | | backward |
->| | | | integration |
->| | | | [default: equal |
->| | | | to lower_bandwi |
->| | | | dth] |
->+-----------------+-----------------+-----------------+-----------------+
->| max_krylov | OT_INTEGER | 10 | Maximum Krylov |
->| | | | subspace size |
->+-----------------+-----------------+-----------------+-----------------+
->| max_krylovB | OT_INTEGER | GenericType() | Maximum krylov |
->| | | | subspace size |
->+-----------------+-----------------+-----------------+-----------------+
->| max_multistep_o | OT_INTEGER | 5 | |
->| rder | | | |
->+-----------------+-----------------+-----------------+-----------------+
->| max_num_steps | OT_INTEGER | 10000 | Maximum number |
->| | | | of integrator |
->| | | | steps |
->+-----------------+-----------------+-----------------+-----------------+
->| max_step_size | OT_REAL | 0 | Maximim step |
->| | | | size |
->+-----------------+-----------------+-----------------+-----------------+
->| pretype | OT_STRING | "none" | (none|left|righ |
->| | | | t|both) |
->+-----------------+-----------------+-----------------+-----------------+
->| pretypeB | OT_STRING | GenericType() | (none|left|righ |
->| | | | t|both) |
->+-----------------+-----------------+-----------------+-----------------+
->| quad_err_con | OT_BOOLEAN | false | Should the |
->| | | | quadratures |
->| | | | affect the step |
->| | | | size control |
->+-----------------+-----------------+-----------------+-----------------+
->| reltol | OT_REAL | 0.000 | Relative |
->| | | | tolerence for |
->| | | | the IVP |
->| | | | solution |
->+-----------------+-----------------+-----------------+-----------------+
->| reltolB | OT_REAL | GenericType() | Relative |
->| | | | tolerence for |
->| | | | the adjoint |
->| | | | sensitivity |
->| | | | solution |
->| | | | [default: equal |
->| | | | to reltol] |
->+-----------------+-----------------+-----------------+-----------------+
->| sensitivity_met | OT_STRING | "simultaneous" | (simultaneous|s |
->| hod | | | taggered) |
->+-----------------+-----------------+-----------------+-----------------+
->| steps_per_check | OT_INTEGER | 20 | Number of steps |
->| point | | | between two |
->| | | | consecutive |
->| | | | checkpoints |
->+-----------------+-----------------+-----------------+-----------------+
->| stop_at_end | OT_BOOLEAN | true | Stop the |
->| | | | integrator at |
->| | | | the end of the |
->| | | | interval |
->+-----------------+-----------------+-----------------+-----------------+
->| suppress_algebr | OT_BOOLEAN | false | Supress |
->| aic | | | algebraic |
->| | | | variables in |
->| | | | the error |
->| | | | testing |
->+-----------------+-----------------+-----------------+-----------------+
->| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
->| | | | width of banded |
->| | | | Jacobian |
->| | | | (estimations) |
->+-----------------+-----------------+-----------------+-----------------+
->| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
->| B | | | width of banded |
->| | | | jacobians for |
->| | | | backward |
->| | | | integration |
->| | | | [default: equal |
->| | | | to upper_bandwi |
->| | | | dth] |
->+-----------------+-----------------+-----------------+-----------------+
->| use_preconditio | OT_BOOLEAN | false | Precondition an |
->| ner | | | iterative |
->| | | | solver |
->+-----------------+-----------------+-----------------+-----------------+
->| use_preconditio | OT_BOOLEAN | GenericType() | Precondition an |
->| nerB | | | iterative |
->| | | | solver for the |
->| | | | backwards |
->| | | | problem |
->| | | | [default: equal |
->| | | | to use_precondi |
->| | | | tioner] |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+--------------------------+
->| Id |
->+==========================+
->| bjacB |
->+--------------------------+
->| correctInitialConditions |
->+--------------------------+
->| jtimesB |
->+--------------------------+
->| psetup |
->+--------------------------+
->| psetupB |
->+--------------------------+
->| psolveB |
->+--------------------------+
->| res |
->+--------------------------+
->| resB |
->+--------------------------+
->| resS |
->+--------------------------+
->| rhsQB |
->+--------------------------+
->
->>List of available stats
->
->+-------------+
->| Id |
->+=============+
->| nlinsetups |
->+-------------+
->| nlinsetupsB |
->+-------------+
->| nsteps |
->+-------------+
->| nstepsB |
->+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->collocation
->-----------
->
->
->
->Fixed-step implicit Runge-Kutta integrator ODE/DAE integrator based on
->collocation schemes
->
->The method is still under development
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| collocation_sch | OT_STRING | "radau" | Collocation |
->| eme | | | scheme (radau|l |
->| | | | egendre) |
->+-----------------+-----------------+-----------------+-----------------+
->| implicit_solver | OT_STRING | GenericType() | An implicit |
->| | | | function solver |
->+-----------------+-----------------+-----------------+-----------------+
->| implicit_solver | OT_DICTIONARY | GenericType() | Options to be |
->| _options | | | passed to the |
->| | | | NLP Solver |
->+-----------------+-----------------+-----------------+-----------------+
->| interpolation_o | OT_INTEGER | 3 | Order of the |
->| rder | | | interpolating |
->| | | | polynomials |
->+-----------------+-----------------+-----------------+-----------------+
->| number_of_finit | OT_INTEGER | 20 | Number of |
->| e_elements | | | finite elements |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->oldcollocation
->--------------
->
->
->
->Collocation integrator ODE/DAE integrator based on collocation
->
->The method is still under development
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| collocation_sch | OT_STRING | "radau" | Collocation |
->| eme | | | scheme (radau|l |
->| | | | egendre) |
->+-----------------+-----------------+-----------------+-----------------+
->| expand_f | OT_BOOLEAN | false | Expand the |
->| | | | ODE/DAE |
->| | | | residual |
->| | | | function in an |
->| | | | SX graph |
->+-----------------+-----------------+-----------------+-----------------+
->| expand_q | OT_BOOLEAN | false | Expand the |
->| | | | quadrature |
->| | | | function in an |
->| | | | SX graph |
->+-----------------+-----------------+-----------------+-----------------+
->| hotstart | OT_BOOLEAN | true | Initialize the |
->| | | | trajectory at |
->| | | | the previous |
->| | | | solution |
->+-----------------+-----------------+-----------------+-----------------+
->| implicit_solver | OT_STRING | GenericType() | An implicit |
->| | | | function solver |
->+-----------------+-----------------+-----------------+-----------------+
->| implicit_solver | OT_DICTIONARY | GenericType() | Options to be |
->| _options | | | passed to the |
->| | | | implicit solver |
->+-----------------+-----------------+-----------------+-----------------+
->| interpolation_o | OT_INTEGER | 3 | Order of the |
->| rder | | | interpolating |
->| | | | polynomials |
->+-----------------+-----------------+-----------------+-----------------+
->| number_of_finit | OT_INTEGER | 20 | Number of |
->| e_elements | | | finite elements |
->+-----------------+-----------------+-----------------+-----------------+
->| startup_integra | OT_STRING | GenericType() | An ODE/DAE |
->| tor | | | integrator that |
->| | | | can be used to |
->| | | | generate a |
->| | | | startup |
->| | | | trajectory |
->+-----------------+-----------------+-----------------+-----------------+
->| startup_integra | OT_DICTIONARY | GenericType() | Options to be |
->| tor_options | | | passed to the |
->| | | | startup |
->| | | | integrator |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->rk --
->
->
->
->Fixed-step explicit Runge-Kutta integrator for ODEs Currently implements
->RK4.
->
->The method is still under development
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| number_of_finit | OT_INTEGER | 20 | Number of |
->| e_elements | | | finite elements |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: integrator.hpp
--}
-newtype Integrator = Integrator (ForeignPtr Integrator')
--- typeclass decl
-class IntegratorClass a where
- castIntegrator :: a -> Integrator
-instance IntegratorClass Integrator where
- castIntegrator = id
-
--- baseclass instances
-instance FunctionClass Integrator where
- castFunction (Integrator x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Integrator where
- castOptionsFunctionality (Integrator x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass Integrator where
- castPrintableObject (Integrator x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass Integrator where
- castSharedObject (Integrator x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Integrator where
- castIOInterfaceFunction (Integrator x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Integrator (Ptr Integrator') where
- marshal (Integrator x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Integrator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Integrator"
- c_delete_casadi__Integrator :: FunPtr (Ptr Integrator' -> IO ())
-instance WrapReturn (Ptr Integrator') Integrator where
- wrapReturn = (fmap Integrator) . (newForeignPtr c_delete_casadi__Integrator)
-
-
--- raw decl
-data LinearSolver'
--- data decl
-{-|
->Base class for the linear solver classes.
->
->Solves the linear system A*X = B or A^T*X = B for X with A square and non-
->singular
->
->If A is structurally singular, an error will be thrown during init. If A is
->numerically singular, the prepare step will fail.
->
->The usual procedure to use LinearSolver is: init()
->
->set the first input (A)
->
->prepare()
->
->set the second input (b)
->
->solve()
->
->Repeat steps 4 and 5 to work with other b vectors.
->
->The method evaluate() combines the prepare() and solve() step and is
->therefore more expensive if A is invariant.
->
->General information
->===================
->
->
->
->>Input scheme: casadi::LinsolInput (LINSOL_NUM_IN = 2) [linsolIn]
->
->+-----------+-------+------------------------------------------------+
->| Full name | Short | Description |
->+===========+=======+================================================+
->| LINSOL_A | A | The square matrix A: sparse, (n x n). . |
->+-----------+-------+------------------------------------------------+
->| LINSOL_B | B | The right-hand-side matrix b: dense, (n x m) . |
->+-----------+-------+------------------------------------------------+
->
->>Output scheme: casadi::LinsolOutput (LINSOL_NUM_OUT = 1) [linsolOut]
->
->+-----------+-------+----------------------------------------------+
->| Full name | Short | Description |
->+===========+=======+==============================================+
->| LINSOL_X | X | Solution to the linear system of equations . |
->+-----------+-------+----------------------------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- csparsecholesky
->
->- csparse
->
->- lapacklu
->
->- lapackqr
->
->- symbolicqr
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->LinearSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->csparsecholesky
->---------------
->
->
->
->LinearSolver with CSparseCholesky Interface
->
->>List of available options
->
->+----+------+---------+-------------+
->| Id | Type | Default | Description |
->+====+======+=========+=============+
->+----+------+---------+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->csparse
->-------
->
->
->
->LinearSolver with CSparse Interface
->
->>List of available options
->
->+----+------+---------+-------------+
->| Id | Type | Default | Description |
->+====+======+=========+=============+
->+----+------+---------+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->lapacklu
->--------
->
->
->
->This class solves the linear system A.x=b by making an LU factorization of
->A: A = L.U, with L lower and U upper triangular
->
->>List of available options
->
->+-----------------------------+------------+---------+-------------+
->| Id | Type | Default | Description |
->+=============================+============+=========+=============+
->| allow_equilibration_failure | OT_BOOLEAN | false | |
->+-----------------------------+------------+---------+-------------+
->| equilibration | OT_BOOLEAN | true | |
->+-----------------------------+------------+---------+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->lapackqr
->--------
->
->
->
->This class solves the linear system A.x=b by making an QR factorization of
->A: A = Q.R, with Q orthogonal and R upper triangular
->
->>List of available options
->
->+----+------+---------+-------------+
->| Id | Type | Default | Description |
->+====+======+=========+=============+
->+----+------+---------+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->symbolicqr
->----------
->
->
->
->LinearSolver based on QR factorization with sparsity pattern based
->reordering without partial pivoting
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| codegen | OT_BOOLEAN | false | C-code |
->| | | | generation |
->+-----------------+-----------------+-----------------+-----------------+
->| compiler | OT_STRING | "gcc -fPIC -O2" | Compiler |
->| | | | command to be |
->| | | | used for |
->| | | | compiling |
->| | | | generated code |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: linear_solver.hpp
--}
-newtype LinearSolver = LinearSolver (ForeignPtr LinearSolver')
--- typeclass decl
-class LinearSolverClass a where
- castLinearSolver :: a -> LinearSolver
-instance LinearSolverClass LinearSolver where
- castLinearSolver = id
-
--- baseclass instances
-instance FunctionClass LinearSolver where
- castFunction (LinearSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass LinearSolver where
- castOptionsFunctionality (LinearSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass LinearSolver where
- castPrintableObject (LinearSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass LinearSolver where
- castSharedObject (LinearSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass LinearSolver where
- castIOInterfaceFunction (LinearSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal LinearSolver (Ptr LinearSolver') where
- marshal (LinearSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (LinearSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__LinearSolver"
- c_delete_casadi__LinearSolver :: FunPtr (Ptr LinearSolver' -> IO ())
-instance WrapReturn (Ptr LinearSolver') LinearSolver where
- wrapReturn = (fmap LinearSolver) . (newForeignPtr c_delete_casadi__LinearSolver)
-
-
--- raw decl
-data LpSolver'
--- data decl
-{-|
->LpSolver.
->
->Solves the following linear problem:
->
->
->
->::
->
-> min c' x
-> x
->
-> subject to
-> LBA <= A x <= UBA
-> LBX <= x <= UBX
->
-> with x ( n x 1)
-> c ( n x 1 )
-> A sparse matrix ( nc x n)
-> LBA, UBA dense vector (nc x 1)
-> LBX, UBX dense vector (n x 1)
->
-> n: number of decision variables (x)
-> nc: number of constraints (A)
->
->
->
->General information
->===================
->
->
->
->>Input scheme: casadi::LpSolverInput (LP_SOLVER_NUM_IN = 6) [lpIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| LP_SOLVER_C | c | The vector c: dense (n |
->| | | x 1) . |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_A | a | The matrix A: sparse, |
->| | | (nc x n) - product |
->| | | with x must be dense. |
->| | | . |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_LBA | lba | dense, (nc x 1) |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_UBA | uba | dense, (nc x 1) |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_LBX | lbx | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_UBX | ubx | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::LpSolverOutput (LP_SOLVER_NUM_OUT = 4) [lpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| LP_SOLVER_X | x | The primal solution . |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_COST | cost | The optimal cost . |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_LAM_A | lam_a | The dual solution |
->| | | corresponding to |
->| | | linear bounds . |
->+------------------------+------------------------+------------------------+
->| LP_SOLVER_LAM_X | lam_x | The dual solution |
->| | | corresponding to |
->| | | simple bounds . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- qp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->LpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->qp --
->
->
->
->Solve LPs using a QpSolver
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| qp_solver | OT_STRING | GenericType() | The QPSOlver |
->| | | | used to solve |
->| | | | the LPs. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_solver_optio | OT_DICTIONARY | GenericType() | Options to be |
->| ns | | | passed to the |
->| | | | QPSOlver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+-----------------+
->| Id |
->+=================+
->| qp_solver_stats |
->+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joris Gillis
->Diagrams
->--------
->
->
->
->C++ includes: lp_solver.hpp
--}
-newtype LpSolver = LpSolver (ForeignPtr LpSolver')
--- typeclass decl
-class LpSolverClass a where
- castLpSolver :: a -> LpSolver
-instance LpSolverClass LpSolver where
- castLpSolver = id
-
--- baseclass instances
-instance FunctionClass LpSolver where
- castFunction (LpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass LpSolver where
- castOptionsFunctionality (LpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass LpSolver where
- castPrintableObject (LpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass LpSolver where
- castSharedObject (LpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass LpSolver where
- castIOInterfaceFunction (LpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal LpSolver (Ptr LpSolver') where
- marshal (LpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (LpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__LpSolver"
- c_delete_casadi__LpSolver :: FunPtr (Ptr LpSolver' -> IO ())
-instance WrapReturn (Ptr LpSolver') LpSolver where
- wrapReturn = (fmap LpSolver) . (newForeignPtr c_delete_casadi__LpSolver)
-
-
--- raw decl
-data MX'
--- data decl
-{-|
--}
-newtype MX = MX (ForeignPtr MX')
--- typeclass decl
-class MXClass a where
- castMX :: a -> MX
-instance MXClass MX where
- castMX = id
-
--- baseclass instances
-instance PrintableObjectClass MX where
- castPrintableObject (MX x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass MX where
- castSharedObject (MX x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal MX (Ptr MX') where
- marshal (MX x) = return (unsafeForeignPtrToPtr x)
- marshalFree (MX x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__MX"
- c_delete_casadi__MX :: FunPtr (Ptr MX' -> IO ())
-instance WrapReturn (Ptr MX') MX where
- wrapReturn = (fmap MX) . (newForeignPtr c_delete_casadi__MX)
-
-
--- raw decl
-data MXFunction'
--- data decl
-{-|
->General function mapping from/to MX.
->
->Joel Andersson
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: mx_function.hpp
--}
-newtype MXFunction = MXFunction (ForeignPtr MXFunction')
--- typeclass decl
-class MXFunctionClass a where
- castMXFunction :: a -> MXFunction
-instance MXFunctionClass MXFunction where
- castMXFunction = id
-
--- baseclass instances
-instance FunctionClass MXFunction where
- castFunction (MXFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass MXFunction where
- castOptionsFunctionality (MXFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass MXFunction where
- castPrintableObject (MXFunction x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass MXFunction where
- castSharedObject (MXFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass MXFunction where
- castIOInterfaceFunction (MXFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal MXFunction (Ptr MXFunction') where
- marshal (MXFunction x) = return (unsafeForeignPtrToPtr x)
- marshalFree (MXFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__MXFunction"
- c_delete_casadi__MXFunction :: FunPtr (Ptr MXFunction' -> IO ())
-instance WrapReturn (Ptr MXFunction') MXFunction where
- wrapReturn = (fmap MXFunction) . (newForeignPtr c_delete_casadi__MXFunction)
-
-
--- raw decl
-data NlpSolver'
--- data decl
-{-|
->NlpSolver.
->
->Solves the following parametric nonlinear program (NLP):
->
->::
->
-> min F(x, p)
-> x
->
-> subject to
-> LBX <= x <= UBX
-> LBG <= G(x, p) <= UBG
-> p == P
->
-> nx: number of decision variables
-> ng: number of constraints
-> np: number of parameters
->
->
->
->
->General information
->===================
->
->
->
->>Input scheme: casadi::NlpSolverInput (NLP_SOLVER_NUM_IN = 8) [nlpSolverIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| NLP_SOLVER_X0 | x0 | Decision variables, |
->| | | initial guess (nx x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_P | p | Value of fixed |
->| | | parameters (np x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LBX | lbx | Decision variables |
->| | | lower bound (nx x 1), |
->| | | default -inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_UBX | ubx | Decision variables |
->| | | upper bound (nx x 1), |
->| | | default +inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LBG | lbg | Constraints lower |
->| | | bound (ng x 1), |
->| | | default -inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_UBG | ubg | Constraints upper |
->| | | bound (ng x 1), |
->| | | default +inf . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_X0 | lam_x0 | Lagrange multipliers |
->| | | for bounds on X, |
->| | | initial guess (nx x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_G0 | lam_g0 | Lagrange multipliers |
->| | | for bounds on G, |
->| | | initial guess (ng x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::NlpSolverOutput (NLP_SOLVER_NUM_OUT = 6) [nlpSolverOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| NLP_SOLVER_X | x | Decision variables at |
->| | | the optimal solution |
->| | | (nx x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_F | f | Cost function value at |
->| | | the optimal solution |
->| | | (1 x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_G | g | Constraints function |
->| | | at the optimal |
->| | | solution (ng x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_X | lam_x | Lagrange multipliers |
->| | | for bounds on X at the |
->| | | solution (nx x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_G | lam_g | Lagrange multipliers |
->| | | for bounds on G at the |
->| | | solution (ng x 1) . |
->+------------------------+------------------------+------------------------+
->| NLP_SOLVER_LAM_P | lam_p | Lagrange multipliers |
->| | | for bounds on P at the |
->| | | solution (np x 1) . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| eval_errors_ | OT_BOOLEAN | false | When errors | casadi::NlpS |
->| fatal | | | occur during | olverInterna |
->| | | | evaluation | l |
->| | | | of | |
->| | | | f,g,...,stop | |
->| | | | the | |
->| | | | iterations | |
->+--------------+--------------+--------------+--------------+--------------+
->| expand | OT_BOOLEAN | false | Expand the | casadi::NlpS |
->| | | | NLP function | olverInterna |
->| | | | in terms of | l |
->| | | | scalar | |
->| | | | operations, | |
->| | | | i.e. MX->SX | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| grad_f | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
->| | | ) | calculating | olverInterna |
->| | | | the gradient | l |
->| | | | of the | |
->| | | | objective | |
->| | | | (column, aut | |
->| | | | ogenerated | |
->| | | | by default) | |
->+--------------+--------------+--------------+--------------+--------------+
->| grad_lag | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
->| | | ) | calculating | olverInterna |
->| | | | the gradient | l |
->| | | | of the | |
->| | | | Lagrangian ( | |
->| | | | autogenerate | |
->| | | | d by | |
->| | | | default) | |
->+--------------+--------------+--------------+--------------+--------------+
->| hess_lag | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
->| | | ) | calculating | olverInterna |
->| | | | the Hessian | l |
->| | | | of the | |
->| | | | Lagrangian ( | |
->| | | | autogenerate | |
->| | | | d by | |
->| | | | default) | |
->+--------------+--------------+--------------+--------------+--------------+
->| ignore_check | OT_BOOLEAN | false | If set to | casadi::NlpS |
->| _vec | | | true, the | olverInterna |
->| | | | input shape | l |
->| | | | of F will | |
->| | | | not be | |
->| | | | checked. | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| iteration_ca | OT_CALLBACK | GenericType( | A function | casadi::NlpS |
->| llback | | ) | that will be | olverInterna |
->| | | | called at | l |
->| | | | each | |
->| | | | iteration | |
->| | | | with the | |
->| | | | solver as | |
->| | | | input. Check | |
->| | | | documentatio | |
->| | | | n of | |
->| | | | Callback . | |
->+--------------+--------------+--------------+--------------+--------------+
->| iteration_ca | OT_BOOLEAN | false | If set to | casadi::NlpS |
->| llback_ignor | | | true, errors | olverInterna |
->| e_errors | | | thrown by it | l |
->| | | | eration_call | |
->| | | | back will be | |
->| | | | ignored. | |
->+--------------+--------------+--------------+--------------+--------------+
->| iteration_ca | OT_INTEGER | 1 | Only call | casadi::NlpS |
->| llback_step | | | the callback | olverInterna |
->| | | | function | l |
->| | | | every few | |
->| | | | iterations. | |
->+--------------+--------------+--------------+--------------+--------------+
->| jac_f | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
->| | | ) | calculating | olverInterna |
->| | | | the jacobian | l |
->| | | | of the | |
->| | | | objective | |
->| | | | (sparse row, | |
->| | | | autogenerate | |
->| | | | d by | |
->| | | | default) | |
->+--------------+--------------+--------------+--------------+--------------+
->| jac_g | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
->| | | ) | calculating | olverInterna |
->| | | | the Jacobian | l |
->| | | | of the | |
->| | | | constraints | |
->| | | | (autogenerat | |
->| | | | ed by | |
->| | | | default) | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->| warn_initial | OT_BOOLEAN | false | Warn if the | casadi::NlpS |
->| _bounds | | | initial | olverInterna |
->| | | | guess does | l |
->| | | | not satisfy | |
->| | | | LBX and UBX | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- ipopt
->
->- knitro
->
->- snopt
->
->- worhp
->
->- scpgen
->
->- sqpmethod
->
->- stabilizedsqp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->NlpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->ipopt
->-----
->
->
->
->When in warmstart mode, output NLP_SOLVER_LAM_X may be used as input
->
->NOTE: Even when max_iter == 0, it is not guaranteed that
->input(NLP_SOLVER_X0) == output(NLP_SOLVER_X). Indeed if bounds on X or
->constraints are unmet, they will differ.
->
->For a good tutorial on IPOPT,
->seehttp://drops.dagstuhl.de/volltexte/2009/2089/pdf/09061.WaechterAndreas.Paper.2089.pdf
->
->A good resource about the algorithms in IPOPT is: Wachter and L. T. Biegler,
->On the Implementation of an Interior-Point Filter Line-Search Algorithm for
->Large-Scale Nonlinear Programming, Mathematical Programming 106(1), pp.
->25-57, 2006 (As Research Report RC 23149, IBM T. J. Watson Research Center,
->Yorktown, USA
->
->Caveats: with default options, multipliers for the decision variables are
->wrong for equality constraints. Change the 'fixed_variable_treatment' to
->'make_constraint' or 'relax_bounds' to obtain correct results.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| accept_after_ma | OT_INTEGER | -1 | Accept a trial |
->| x_steps | | | point after |
->| | | | maximal this |
->| | | | number of |
->| | | | steps. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| accept_every_tr | OT_STRING | no | Always accept |
->| ial_step | | | the first trial |
->| | | | step. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| acceptable_comp | OT_REAL | 0.010 | "Acceptance" |
->| l_inf_tol | | | threshold for |
->| | | | the |
->| | | | complementarity |
->| | | | conditions. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| acceptable_cons | OT_REAL | 0.010 | "Acceptance" |
->| tr_viol_tol | | | threshold for |
->| | | | the constraint |
->| | | | violation. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| acceptable_dual | OT_REAL | 1.000e+10 | "Acceptance" |
->| _inf_tol | | | threshold for |
->| | | | the dual |
->| | | | infeasibility. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| acceptable_iter | OT_INTEGER | 15 | Number of |
->| | | | "acceptable" |
->| | | | iterates before |
->| | | | triggering |
->| | | | termination. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| acceptable_obj_ | OT_REAL | 1.000e+20 | "Acceptance" |
->| change_tol | | | stopping |
->| | | | criterion based |
->| | | | on objective |
->| | | | function |
->| | | | change. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| acceptable_tol | OT_REAL | 0.000 | "Acceptable" |
->| | | | convergence |
->| | | | tolerance |
->| | | | (relative). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| adaptive_mu_glo | OT_STRING | obj-constr- | Globalization |
->| balization | | filter | strategy for |
->| | | | the adaptive mu |
->| | | | selection mode. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| adaptive_mu_kkt | OT_STRING | 2-norm-squared | Norm used for |
->| _norm_type | | | the KKT error |
->| | | | in the adaptive |
->| | | | mu |
->| | | | globalization |
->| | | | strategies. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| adaptive_mu_kkt | OT_REAL | 1.000 | Sufficient |
->| error_red_fact | | | decrease factor |
->| | | | for "kkt-error" |
->| | | | globalization |
->| | | | strategy. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| adaptive_mu_kkt | OT_INTEGER | 4 | Maximum number |
->| error_red_iters | | | of iterations |
->| | | | requiring |
->| | | | sufficient |
->| | | | progress. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| adaptive_mu_mon | OT_REAL | 0.800 | Determines the |
->| otone_init_fact | | | initial value |
->| or | | | of the barrier |
->| | | | parameter when |
->| | | | switching to |
->| | | | the monotone |
->| | | | mode. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| adaptive_mu_res | OT_STRING | no | Indicates if |
->| tore_previous_i | | | the previous |
->| terate | | | iterate should |
->| | | | be restored if |
->| | | | the monotone |
->| | | | mode is |
->| | | | entered. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| adaptive_mu_saf | OT_REAL | 0 | (see IPOPT |
->| eguard_factor | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| alpha_for_y | OT_STRING | primal | Method to |
->| | | | determine the |
->| | | | step size for |
->| | | | constraint |
->| | | | multipliers. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| alpha_for_y_tol | OT_REAL | 10 | Tolerance for |
->| | | | switching to |
->| | | | full equality |
->| | | | multiplier |
->| | | | steps. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| alpha_min_frac | OT_REAL | 0.050 | Safety factor |
->| | | | for the minimal |
->| | | | step size |
->| | | | (before |
->| | | | switching to |
->| | | | restoration |
->| | | | phase). (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| alpha_red_facto | OT_REAL | 0.500 | Fractional |
->| r | | | reduction of |
->| | | | the trial step |
->| | | | size in the |
->| | | | backtracking |
->| | | | line search. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| barrier_tol_fac | OT_REAL | 10 | Factor for mu |
->| tor | | | in barrier stop |
->| | | | test. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| bound_frac | OT_REAL | 0.010 | Desired minimum |
->| | | | relative |
->| | | | distance from |
->| | | | the initial |
->| | | | point to bound. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| bound_mult_init | OT_STRING | constant | Initialization |
->| _method | | | method for |
->| | | | bound |
->| | | | multipliers |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| bound_mult_init | OT_REAL | 1 | Initial value |
->| _val | | | for the bound |
->| | | | multipliers. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| bound_mult_rese | OT_REAL | 1000 | Threshold for |
->| t_threshold | | | resetting bound |
->| | | | multipliers |
->| | | | after the |
->| | | | restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| bound_push | OT_REAL | 0.010 | Desired minimum |
->| | | | absolute |
->| | | | distance from |
->| | | | the initial |
->| | | | point to bound. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| bound_relax_fac | OT_REAL | 0.000 | Factor for |
->| tor | | | initial |
->| | | | relaxation of |
->| | | | the bounds. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| check_derivativ | OT_STRING | no | Indicates |
->| es_for_naninf | | | whether it is |
->| | | | desired to |
->| | | | check for |
->| | | | Nan/Inf in |
->| | | | derivative |
->| | | | matrices (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| chi_cup | OT_REAL | 1.500 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| chi_hat | OT_REAL | 2 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| chi_tilde | OT_REAL | 5 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| compl_inf_tol | OT_REAL | 0.000 | Desired |
->| | | | threshold for |
->| | | | the |
->| | | | complementarity |
->| | | | conditions. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| con_integer_md | OT_DICTIONARY | None | Integer |
->| | | | metadata (a |
->| | | | dictionary with |
->| | | | lists of |
->| | | | integers) about |
->| | | | constraints to |
->| | | | be passed to |
->| | | | IPOPT |
->+-----------------+-----------------+-----------------+-----------------+
->| con_numeric_md | OT_DICTIONARY | None | Numeric |
->| | | | metadata (a |
->| | | | dictionary with |
->| | | | lists of reals) |
->| | | | about |
->| | | | constraints to |
->| | | | be passed to |
->| | | | IPOPT |
->+-----------------+-----------------+-----------------+-----------------+
->| con_string_md | OT_DICTIONARY | None | String metadata |
->| | | | (a dictionary |
->| | | | with lists of |
->| | | | strings) about |
->| | | | constraints to |
->| | | | be passed to |
->| | | | IPOPT |
->+-----------------+-----------------+-----------------+-----------------+
->| constr_mult_ini | OT_REAL | 1000 | Maximum allowed |
->| t_max | | | least-square |
->| | | | guess of |
->| | | | constraint |
->| | | | multipliers. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| constr_mult_res | OT_REAL | 0 | Threshold for |
->| et_threshold | | | resetting |
->| | | | equality and |
->| | | | inequality |
->| | | | multipliers |
->| | | | after |
->| | | | restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| constr_viol_tol | OT_REAL | 0.000 | Desired |
->| | | | threshold for |
->| | | | the constraint |
->| | | | violation. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| constraint_viol | OT_STRING | 1-norm | Norm to be used |
->| ation_norm_type | | | for the |
->| | | | constraint |
->| | | | violation in |
->| | | | the line |
->| | | | search. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| corrector_compl | OT_REAL | 1 | Complementarity |
->| _avrg_red_fact | | | tolerance |
->| | | | factor for |
->| | | | accepting |
->| | | | corrector step |
->| | | | (unsupported!). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| corrector_type | OT_STRING | none | The type of |
->| | | | corrector steps |
->| | | | that should be |
->| | | | taken |
->| | | | (unsupported!). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| delta | OT_REAL | 1 | Multiplier for |
->| | | | constraint |
->| | | | violation in |
->| | | | the switching |
->| | | | rule. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| delta_y_max | OT_REAL | 1.000e+12 | a parameter |
->| | | | used to check |
->| | | | if the fast |
->| | | | direction can |
->| | | | be used asthe |
->| | | | line search |
->| | | | direction (for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| dependency_dete | OT_STRING | no | Indicates if |
->| ction_with_rhs | | | the right hand |
->| | | | sides of the |
->| | | | constraints |
->| | | | should be |
->| | | | considered |
->| | | | during |
->| | | | dependency |
->| | | | detection (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| dependency_dete | OT_STRING | none | Indicates which |
->| ctor | | | linear solver |
->| | | | should be used |
->| | | | to detect |
->| | | | linearly |
->| | | | dependent |
->| | | | equality |
->| | | | constraints. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| derivative_test | OT_STRING | none | Enable |
->| | | | derivative |
->| | | | checker (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| derivative_test | OT_INTEGER | -2 | Index of first |
->| _first_index | | | quantity to be |
->| | | | checked by |
->| | | | derivative |
->| | | | checker (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| derivative_test | OT_REAL | 0.000 | Size of the |
->| _perturbation | | | finite |
->| | | | difference |
->| | | | perturbation in |
->| | | | derivative |
->| | | | test. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| derivative_test | OT_STRING | no | Indicates |
->| _print_all | | | whether |
->| | | | information for |
->| | | | all estimated |
->| | | | derivatives |
->| | | | should be |
->| | | | printed. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| derivative_test | OT_REAL | 0.000 | Threshold for |
->| _tol | | | indicating |
->| | | | wrong |
->| | | | derivative. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| diverging_itera | OT_REAL | 1.000e+20 | Threshold for |
->| tes_tol | | | maximal value |
->| | | | of primal |
->| | | | iterates. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| dual_inf_tol | OT_REAL | 1 | Desired |
->| | | | threshold for |
->| | | | the dual |
->| | | | infeasibility. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| epsilon_c | OT_REAL | 0.010 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| eta_min | OT_REAL | 10 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| eta_penalty | OT_REAL | 0.000 | Relaxation |
->| | | | factor in the |
->| | | | Armijo |
->| | | | condition for |
->| | | | the penalty |
->| | | | function. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| eta_phi | OT_REAL | 0.000 | Relaxation |
->| | | | factor in the |
->| | | | Armijo |
->| | | | condition. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| evaluate_orig_o | OT_STRING | yes | Determines if |
->| bj_at_resto_tri | | | the original |
->| al | | | objective |
->| | | | function should |
->| | | | be evaluated at |
->| | | | restoration |
->| | | | phase trial |
->| | | | points. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| expect_infeasib | OT_STRING | no | Enable |
->| le_problem | | | heuristics to |
->| | | | quickly detect |
->| | | | an infeasible |
->| | | | problem. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| expect_infeasib | OT_REAL | 0.001 | Threshold for |
->| le_problem_ctol | | | disabling "expe |
->| | | | ct_infeasible_p |
->| | | | roblem" option. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| expect_infeasib | OT_REAL | 100000000 | Multiplier |
->| le_problem_ytol | | | threshold for |
->| | | | activating "exp |
->| | | | ect_infeasible_ |
->| | | | problem" |
->| | | | option. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| fast_des_fact | OT_REAL | 0.100 | a parameter |
->| | | | used to check |
->| | | | if the fast |
->| | | | direction can |
->| | | | be used asthe |
->| | | | line search |
->| | | | direction (for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| fast_step_compu | OT_STRING | no | Indicates if |
->| tation | | | the linear |
->| | | | system should |
->| | | | be solved |
->| | | | quickly. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| file_print_leve | OT_INTEGER | 5 | Verbosity level |
->| l | | | for output |
->| | | | file. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| filter_margin_f | OT_REAL | 0.000 | Factor |
->| act | | | determining |
->| | | | width of margin |
->| | | | for obj-constr- |
->| | | | filter adaptive |
->| | | | globalization |
->| | | | strategy. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| filter_max_marg | OT_REAL | 1 | Maximum width |
->| in | | | of margin in |
->| | | | obj-constr- |
->| | | | filter adaptive |
->| | | | globalization |
->| | | | strategy. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| filter_reset_tr | OT_INTEGER | 5 | Number of |
->| igger | | | iterations that |
->| | | | trigger the |
->| | | | filter reset. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| findiff_perturb | OT_REAL | 0.000 | Size of the |
->| ation | | | finite |
->| | | | difference |
->| | | | perturbation |
->| | | | for derivative |
->| | | | approximation. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| first_hessian_p | OT_REAL | 0.000 | Size of first |
->| erturbation | | | x-s |
->| | | | perturbation |
->| | | | tried. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| fixed_mu_oracle | OT_STRING | average_compl | Oracle for the |
->| | | | barrier |
->| | | | parameter when |
->| | | | switching to |
->| | | | fixed mode. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| fixed_variable_ | OT_STRING | make_parameter | Determines how |
->| treatment | | | fixed variables |
->| | | | should be |
->| | | | handled. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| gamma_hat | OT_REAL | 0.040 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| gamma_phi | OT_REAL | 0.000 | Relaxation |
->| | | | factor in the |
->| | | | filter margin |
->| | | | for the barrier |
->| | | | function. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| gamma_theta | OT_REAL | 0.000 | Relaxation |
->| | | | factor in the |
->| | | | filter margin |
->| | | | for the |
->| | | | constraint |
->| | | | violation. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| gamma_tilde | OT_REAL | 4 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| hessian_approxi | OT_STRING | exact | Indicates what |
->| mation | | | Hessian |
->| | | | information is |
->| | | | to be used. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| hessian_approxi | OT_STRING | nonlinear- | Indicates in |
->| mation_space | | variables | which subspace |
->| | | | the Hessian |
->| | | | information is |
->| | | | to be |
->| | | | approximated. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| hessian_constan | OT_STRING | no | Indicates |
->| t | | | whether the |
->| | | | problem is a |
->| | | | quadratic |
->| | | | problem (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| honor_original_ | OT_STRING | yes | Indicates |
->| bounds | | | whether final |
->| | | | points should |
->| | | | be projected |
->| | | | into original |
->| | | | bounds. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| inf_pr_output | OT_STRING | original | Determines what |
->| | | | value is |
->| | | | printed in the |
->| | | | "inf_pr" output |
->| | | | column. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| jac_c_constant | OT_STRING | no | Indicates |
->| | | | whether all |
->| | | | equality |
->| | | | constraints are |
->| | | | linear (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| jac_d_constant | OT_STRING | no | Indicates |
->| | | | whether all |
->| | | | inequality |
->| | | | constraints are |
->| | | | linear (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| jacobian_approx | OT_STRING | exact | Specifies |
->| imation | | | technique to |
->| | | | compute |
->| | | | constraint |
->| | | | Jacobian (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| jacobian_regula | OT_REAL | 0.250 | Exponent for mu |
->| rization_expone | | | in the |
->| nt | | | regularization |
->| | | | for rank- |
->| | | | deficient |
->| | | | constraint |
->| | | | Jacobians. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| jacobian_regula | OT_REAL | 0.000 | Size of the |
->| rization_value | | | regularization |
->| | | | for rank- |
->| | | | deficient |
->| | | | constraint |
->| | | | Jacobians. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| kappa_d | OT_REAL | 0.000 | Weight for |
->| | | | linear damping |
->| | | | term (to handle |
->| | | | one-sided |
->| | | | bounds). (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| kappa_sigma | OT_REAL | 1.000e+10 | Factor limiting |
->| | | | the deviation |
->| | | | of dual |
->| | | | variables from |
->| | | | primal |
->| | | | estimates. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| kappa_soc | OT_REAL | 0.990 | Factor in the |
->| | | | sufficient |
->| | | | reduction rule |
->| | | | for second |
->| | | | order |
->| | | | correction. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| kappa_x_dis | OT_REAL | 100 | a parameter |
->| | | | used to check |
->| | | | if the fast |
->| | | | direction can |
->| | | | be used asthe |
->| | | | line search |
->| | | | direction (for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| kappa_y_dis | OT_REAL | 10000 | a parameter |
->| | | | used to check |
->| | | | if the fast |
->| | | | direction can |
->| | | | be used asthe |
->| | | | line search |
->| | | | direction (for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| least_square_in | OT_STRING | no | Least square |
->| it_duals | | | initialization |
->| | | | of all dual |
->| | | | variables (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| least_square_in | OT_STRING | no | Least square |
->| it_primal | | | initialization |
->| | | | of the primal |
->| | | | variables (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_STRING | sherman- | Strategy for |
->| aug_solver | | morrison | solving the |
->| | | | augmented |
->| | | | system for low- |
->| | | | rank Hessian. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_REAL | 1 | Value for B0 in |
->| init_val | | | low-rank |
->| | | | update. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_REAL | 100000000 | Upper bound on |
->| init_val_max | | | value for B0 in |
->| | | | low-rank |
->| | | | update. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_REAL | 0.000 | Lower bound on |
->| init_val_min | | | value for B0 in |
->| | | | low-rank |
->| | | | update. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_STRING | scalar1 | Initialization |
->| initialization | | | strategy for |
->| | | | the limited |
->| | | | memory quasi- |
->| | | | Newton |
->| | | | approximation. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_INTEGER | 6 | Maximum size of |
->| max_history | | | the history for |
->| | | | the limited |
->| | | | quasi-Newton |
->| | | | Hessian |
->| | | | approximation. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_INTEGER | 2 | Threshold for |
->| max_skipping | | | successive |
->| | | | iterations |
->| | | | where update is |
->| | | | skipped. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_STRING | no | Determines if |
->| special_for_res | | | the quasi- |
->| to | | | Newton updates |
->| | | | should be |
->| | | | special during |
->| | | | the restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| limited_memory_ | OT_STRING | bfgs | Quasi-Newton |
->| update_type | | | update formula |
->| | | | for the limited |
->| | | | memory |
->| | | | approximation. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| line_search_met | OT_STRING | filter | Globalization |
->| hod | | | method used in |
->| | | | backtracking |
->| | | | line search |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_scaling_ | OT_STRING | yes | Flag indicating |
->| on_demand | | | that linear |
->| | | | scaling is only |
->| | | | done if it |
->| | | | seems required. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_solver | OT_STRING | mumps | Linear solver |
->| | | | used for step |
->| | | | computations. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| linear_system_s | OT_STRING | none | Method for |
->| caling | | | scaling the |
->| | | | linear system. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma27_ignore_sin | OT_STRING | no | Enables MA27's |
->| gularity | | | ability to |
->| | | | solve a linear |
->| | | | system even if |
->| | | | the matrix is |
->| | | | singular. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma27_la_init_fa | OT_REAL | 5 | Real workspace |
->| ctor | | | memory for |
->| | | | MA27. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma27_liw_init_f | OT_REAL | 5 | Integer |
->| actor | | | workspace |
->| | | | memory for |
->| | | | MA27. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma27_meminc_fac | OT_REAL | 2 | Increment |
->| tor | | | factor for |
->| | | | workspace size |
->| | | | for MA27. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma27_pivtol | OT_REAL | 0.000 | Pivot tolerance |
->| | | | for the linear |
->| | | | solver MA27. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma27_pivtolmax | OT_REAL | 0.000 | Maximum pivot |
->| | | | tolerance for |
->| | | | the linear |
->| | | | solver MA27. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma27_skip_inert | OT_STRING | no | Always pretend |
->| ia_check | | | inertia is |
->| | | | correct. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma28_pivtol | OT_REAL | 0.010 | Pivot tolerance |
->| | | | for linear |
->| | | | solver MA28. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_automatic_ | OT_STRING | no | Controls MA57 |
->| scaling | | | automatic |
->| | | | scaling (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_block_size | OT_INTEGER | 16 | Controls block |
->| | | | size used by |
->| | | | Level 3 BLAS in |
->| | | | MA57BD (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_node_amalg | OT_INTEGER | 16 | Node |
->| amation | | | amalgamation |
->| | | | parameter (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_pivot_orde | OT_INTEGER | 5 | Controls pivot |
->| r | | | order in MA57 |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_pivtol | OT_REAL | 0.000 | Pivot tolerance |
->| | | | for the linear |
->| | | | solver MA57. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_pivtolmax | OT_REAL | 0.000 | Maximum pivot |
->| | | | tolerance for |
->| | | | the linear |
->| | | | solver MA57. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_pre_alloc | OT_REAL | 1.050 | Safety factor |
->| | | | for work space |
->| | | | memory |
->| | | | allocation for |
->| | | | the linear |
->| | | | solver MA57. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma57_small_pivo | OT_INTEGER | 0 | If set to 1, |
->| t_flag | | | then when small |
->| | | | entries defined |
->| | | | by CNTL(2) are |
->| | | | detected they |
->| | | | are removed and |
->| | | | the |
->| | | | corresponding |
->| | | | pivots placed |
->| | | | at the end of |
->| | | | the |
->| | | | factorization. |
->| | | | This can be |
->| | | | particularly |
->| | | | efficient if |
->| | | | the matrix is |
->| | | | highly rank |
->| | | | deficient. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_buffer_lpa | OT_INTEGER | 4096 | Number of |
->| ge | | | scalars per |
->| | | | MA77 buffer |
->| | | | page (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_buffer_npa | OT_INTEGER | 1600 | Number of pages |
->| ge | | | that make up |
->| | | | MA77 buffer |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_file_size | OT_INTEGER | 2097152 | Target size of |
->| | | | each temporary |
->| | | | file for MA77, |
->| | | | scalars per |
->| | | | type (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_maxstore | OT_INTEGER | 0 | Maximum storage |
->| | | | size for MA77 |
->| | | | in-core mode |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_nemin | OT_INTEGER | 8 | Node |
->| | | | Amalgamation |
->| | | | parameter (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_order | OT_STRING | amd | Controls type |
->| | | | of ordering |
->| | | | used by |
->| | | | HSL_MA77 (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_print_leve | OT_INTEGER | -1 | Debug printing |
->| l | | | level for the |
->| | | | linear solver |
->| | | | MA77 (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_small | OT_REAL | 0.000 | Zero Pivot |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_static | OT_REAL | 0 | Static Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_u | OT_REAL | 0.000 | Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma77_umax | OT_REAL | 0.000 | Maximum |
->| | | | Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_nemin | OT_INTEGER | 32 | Node |
->| | | | Amalgamation |
->| | | | parameter (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_order | OT_STRING | amd | Controls type |
->| | | | of ordering |
->| | | | used by |
->| | | | HSL_MA86 (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_print_leve | OT_INTEGER | -1 | Debug printing |
->| l | | | level for the |
->| | | | linear solver |
->| | | | MA86 (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_scaling | OT_STRING | mc64 | Controls |
->| | | | scaling of |
->| | | | matrix (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_small | OT_REAL | 0.000 | Zero Pivot |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_static | OT_REAL | 0 | Static Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_u | OT_REAL | 0.000 | Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma86_umax | OT_REAL | 0.000 | Maximum |
->| | | | Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_nemin | OT_INTEGER | 8 | Node |
->| | | | Amalgamation |
->| | | | parameter (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_order | OT_STRING | auto | Controls type |
->| | | | of ordering |
->| | | | used by |
->| | | | HSL_MA97 (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_print_leve | OT_INTEGER | 0 | Debug printing |
->| l | | | level for the |
->| | | | linear solver |
->| | | | MA97 (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_scaling | OT_STRING | dynamic | Specifies |
->| | | | strategy for |
->| | | | scaling in |
->| | | | HSL_MA97 linear |
->| | | | solver (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_scaling1 | OT_STRING | mc64 | First scaling. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_scaling2 | OT_STRING | mc64 | Second scaling. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_scaling3 | OT_STRING | mc64 | Third scaling. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_small | OT_REAL | 0.000 | Zero Pivot |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_solve_blas | OT_STRING | no | Controls if |
->| 3 | | | blas2 or blas3 |
->| | | | routines are |
->| | | | used for solve |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_switch1 | OT_STRING | od_hd_reuse | First switch, |
->| | | | determine when |
->| | | | ma97_scaling1 |
->| | | | is enabled. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_switch2 | OT_STRING | never | Second switch, |
->| | | | determine when |
->| | | | ma97_scaling2 |
->| | | | is enabled. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_switch3 | OT_STRING | never | Third switch, |
->| | | | determine when |
->| | | | ma97_scaling3 |
->| | | | is enabled. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_u | OT_REAL | 0.000 | Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| ma97_umax | OT_REAL | 0.000 | Maximum |
->| | | | Pivoting |
->| | | | Threshold (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| magic_steps | OT_STRING | no | Enables magic |
->| | | | steps. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_cpu_time | OT_REAL | 1000000 | Maximum number |
->| | | | of CPU seconds. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_filter_rese | OT_INTEGER | 5 | Maximal allowed |
->| ts | | | number of |
->| | | | filter resets |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_hessian_per | OT_REAL | 1.000e+20 | Maximum value |
->| turbation | | | of |
->| | | | regularization |
->| | | | parameter for |
->| | | | handling |
->| | | | negative |
->| | | | curvature. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter | OT_INTEGER | 3000 | Maximum number |
->| | | | of iterations. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_refinement_ | OT_INTEGER | 10 | Maximum number |
->| steps | | | of iterative |
->| | | | refinement |
->| | | | steps per |
->| | | | linear system |
->| | | | solve. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_resto_iter | OT_INTEGER | 3000000 | Maximum number |
->| | | | of successive |
->| | | | iterations in |
->| | | | restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_soc | OT_INTEGER | 4 | Maximum number |
->| | | | of second order |
->| | | | correction |
->| | | | trial steps at |
->| | | | each iteration. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| max_soft_resto_ | OT_INTEGER | 10 | Maximum number |
->| iters | | | of iterations |
->| | | | performed |
->| | | | successively in |
->| | | | soft |
->| | | | restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mehrotra_algori | OT_STRING | no | Indicates if we |
->| thm | | | want to do |
->| | | | Mehrotra's |
->| | | | algorithm. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| min_alpha_prima | OT_REAL | 0.000 | LIFENG WRITES |
->| l | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| min_hessian_per | OT_REAL | 0.000 | Smallest |
->| turbation | | | perturbation of |
->| | | | the Hessian |
->| | | | block. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| min_refinement_ | OT_INTEGER | 1 | Minimum number |
->| steps | | | of iterative |
->| | | | refinement |
->| | | | steps per |
->| | | | linear system |
->| | | | solve. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_allow_fast_m | OT_STRING | yes | Allow skipping |
->| onotone_decreas | | | of barrier |
->| e | | | problem if |
->| | | | barrier test is |
->| | | | already met. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_init | OT_REAL | 0.100 | Initial value |
->| | | | for the barrier |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_linear_decre | OT_REAL | 0.200 | Determines |
->| ase_factor | | | linear decrease |
->| | | | rate of barrier |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_max | OT_REAL | 100000 | Maximum value |
->| | | | for barrier |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_max_fact | OT_REAL | 1000 | Factor for |
->| | | | initialization |
->| | | | of maximum |
->| | | | value for |
->| | | | barrier |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_min | OT_REAL | 0.000 | Minimum value |
->| | | | for barrier |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_oracle | OT_STRING | quality- | Oracle for a |
->| | | function | new barrier |
->| | | | parameter in |
->| | | | the adaptive |
->| | | | strategy. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_strategy | OT_STRING | monotone | Update strategy |
->| | | | for barrier |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_superlinear_ | OT_REAL | 1.500 | Determines |
->| decrease_power | | | superlinear |
->| | | | decrease rate |
->| | | | of barrier |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mu_target | OT_REAL | 0 | Desired value |
->| | | | of complementar |
->| | | | ity. (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mult_diverg_fea | OT_REAL | 0.000 | tolerance for |
->| sibility_tol | | | deciding if the |
->| | | | multipliers are |
->| | | | diverging (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mult_diverg_y_t | OT_REAL | 100000000 | tolerance for |
->| ol | | | deciding if the |
->| | | | multipliers are |
->| | | | diverging (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mumps_dep_tol | OT_REAL | 0 | Pivot threshold |
->| | | | for detection |
->| | | | of linearly |
->| | | | dependent |
->| | | | constraints in |
->| | | | MUMPS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mumps_mem_perce | OT_INTEGER | 1000 | Percentage |
->| nt | | | increase in the |
->| | | | estimated |
->| | | | working space |
->| | | | for MUMPS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mumps_permuting | OT_INTEGER | 7 | Controls |
->| _scaling | | | permuting and |
->| | | | scaling in |
->| | | | MUMPS (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mumps_pivot_ord | OT_INTEGER | 7 | Controls pivot |
->| er | | | order in MUMPS |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mumps_pivtol | OT_REAL | 0.000 | Pivot tolerance |
->| | | | for the linear |
->| | | | solver MUMPS. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mumps_pivtolmax | OT_REAL | 0.100 | Maximum pivot |
->| | | | tolerance for |
->| | | | the linear |
->| | | | solver MUMPS. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| mumps_scaling | OT_INTEGER | 77 | Controls |
->| | | | scaling in |
->| | | | MUMPS (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| neg_curv_test_t | OT_REAL | 0 | Tolerance for |
->| ol | | | heuristic to |
->| | | | ignore wrong |
->| | | | inertia. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| never_use_fact_ | OT_STRING | no | Toggle to |
->| cgpen_direction | | | switch off the |
->| | | | fast Chen- |
->| | | | Goldfarb |
->| | | | direction (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| never_use_piece | OT_STRING | no | Toggle to |
->| wise_penalty_ls | | | switch off the |
->| | | | piecewise |
->| | | | penalty method |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_lower_bound | OT_REAL | -1.000e+19 | any bound less |
->| _inf | | | or equal this |
->| | | | value will be |
->| | | | considered -inf |
->| | | | (i.e. not lower |
->| | | | bounded). (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_scaling_con | OT_REAL | 0 | Target value |
->| str_target_grad | | | for constraint |
->| ient | | | function |
->| | | | gradient size. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_scaling_max | OT_REAL | 100 | Maximum |
->| _gradient | | | gradient after |
->| | | | NLP scaling. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_scaling_met | OT_STRING | gradient-based | Select the |
->| hod | | | technique used |
->| | | | for scaling the |
->| | | | NLP. (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_scaling_min | OT_REAL | 0.000 | Minimum value |
->| _value | | | of gradient- |
->| | | | based scaling |
->| | | | values. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_scaling_obj | OT_REAL | 0 | Target value |
->| _target_gradien | | | for objective |
->| t | | | function |
->| | | | gradient size. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_upper_bound | OT_REAL | 1.000e+19 | any bound |
->| _inf | | | greater or this |
->| | | | value will be |
->| | | | considered +inf |
->| | | | (i.e. not upper |
->| | | | bounded). (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nu_inc | OT_REAL | 0.000 | Increment of |
->| | | | the penalty |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| nu_init | OT_REAL | 0.000 | Initial value |
->| | | | of the penalty |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| num_linear_vari | OT_INTEGER | 0 | Number of |
->| ables | | | linear |
->| | | | variables (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| obj_max_inc | OT_REAL | 5 | Determines the |
->| | | | upper bound on |
->| | | | the acceptable |
->| | | | increase of |
->| | | | barrier |
->| | | | objective |
->| | | | function. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| obj_scaling_fac | OT_REAL | 1 | Scaling factor |
->| tor | | | for the |
->| | | | objective |
->| | | | function. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| option_file_nam | OT_STRING | ipopt.opt | File name of |
->| e | | | options file. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| output_file | OT_STRING | | File name of |
->| | | | desired output |
->| | | | file (leave |
->| | | | unset for no |
->| | | | file output). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iter_co | OT_INTEGER | 5000 | Maximum Size of |
->| arse_size | | | Coarse Grid |
->| | | | Matrix (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iter_dr | OT_REAL | 0.500 | dropping value |
->| opping_factor | | | for incomplete |
->| | | | factor (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iter_dr | OT_REAL | 0.100 | dropping value |
->| opping_schur | | | for sparsify |
->| | | | schur |
->| | | | complement |
->| | | | factor (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iter_in | OT_REAL | 5000000 | (see IPOPT |
->| verse_norm_fact | | | documentation) |
->| or | | | |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iter_ma | OT_INTEGER | 10 | Maximum Size of |
->| x_levels | | | Grid Levels |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iter_ma | OT_INTEGER | 10000000 | max fill for |
->| x_row_fill | | | each row (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iter_re | OT_REAL | 0.000 | Relative |
->| lative_tol | | | Residual |
->| | | | Convergence |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_iterati | OT_STRING | no | Switch on |
->| ve | | | iterative |
->| | | | solver in |
->| | | | Pardiso library |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_matchin | OT_STRING | complete+2x2 | Matching |
->| g_strategy | | | strategy to be |
->| | | | used by Pardiso |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_max_dro | OT_INTEGER | 4 | Maximal number |
->| ptol_correction | | | of decreases of |
->| s | | | drop tolerance |
->| | | | during one |
->| | | | solve. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_max_ite | OT_INTEGER | 500 | Maximum number |
->| r | | | of Krylov- |
->| | | | Subspace |
->| | | | Iteration (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_msglvl | OT_INTEGER | 0 | Pardiso message |
->| | | | level (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_out_of_ | OT_INTEGER | 0 | Enables out-of- |
->| core_power | | | core variant of |
->| | | | Pardiso (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_redo_sy | OT_STRING | no | Toggle for |
->| mbolic_fact_onl | | | handling case |
->| y_if_inertia_wr | | | when elements |
->| ong | | | were perturbed |
->| | | | by Pardiso. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_repeate | OT_STRING | no | Interpretation |
->| d_perturbation_ | | | of perturbed |
->| means_singular | | | elements. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pardiso_skip_in | OT_STRING | no | Always pretend |
->| ertia_check | | | inertia is |
->| | | | correct. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pass_nonlinear_ | OT_BOOLEAN | False | n/a |
->| variables | | | |
->+-----------------+-----------------+-----------------+-----------------+
->| pen_des_fact | OT_REAL | 0.200 | a parameter |
->| | | | used in penalty |
->| | | | parameter |
->| | | | computation |
->| | | | (for Chen- |
->| | | | Goldfarb line |
->| | | | search). (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pen_init_fac | OT_REAL | 50 | a parameter |
->| | | | used to choose |
->| | | | initial penalty |
->| | | | parameterswhen |
->| | | | the regularized |
->| | | | Newton method |
->| | | | is used. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| pen_theta_max_f | OT_REAL | 10000 | Determines |
->| act | | | upper bound for |
->| | | | constraint |
->| | | | violation in |
->| | | | the filter. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| penalty_init_ma | OT_REAL | 100000 | Maximal value |
->| x | | | for the intial |
->| | | | penalty |
->| | | | parameter (for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| penalty_init_mi | OT_REAL | 1 | Minimal value |
->| n | | | for the intial |
->| | | | penalty |
->| | | | parameter for |
->| | | | line search(for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| penalty_max | OT_REAL | 1.000e+30 | Maximal value |
->| | | | for the penalty |
->| | | | parameter (for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| penalty_update_ | OT_REAL | 10 | LIFENG WRITES |
->| compl_tol | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| penalty_update_ | OT_REAL | 0.000 | Threshold for |
->| infeasibility_t | | | infeasibility |
->| ol | | | in penalty |
->| | | | parameter |
->| | | | update test. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| perturb_always_ | OT_STRING | no | Active |
->| cd | | | permanent |
->| | | | perturbation of |
->| | | | constraint |
->| | | | linearization. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| perturb_dec_fac | OT_REAL | 0.333 | Decrease factor |
->| t | | | for x-s |
->| | | | perturbation. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| perturb_inc_fac | OT_REAL | 8 | Increase factor |
->| t | | | for x-s |
->| | | | perturbation. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| perturb_inc_fac | OT_REAL | 100 | Increase factor |
->| t_first | | | for x-s |
->| | | | perturbation |
->| | | | for very first |
->| | | | perturbation. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| piecewisepenalt | OT_REAL | 0.000 | LIFENG WRITES |
->| y_gamma_infeasi | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| piecewisepenalt | OT_REAL | 0.000 | LIFENG WRITES |
->| y_gamma_obj | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| point_perturbat | OT_REAL | 10 | Maximal |
->| ion_radius | | | perturbation of |
->| | | | an evaluation |
->| | | | point. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_frequency | OT_INTEGER | 1 | Determines at |
->| _iter | | | which iteration |
->| | | | frequency the |
->| | | | summarizing |
->| | | | iteration |
->| | | | output line |
->| | | | should be |
->| | | | printed. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_frequency | OT_REAL | 0 | Determines at |
->| _time | | | which time |
->| | | | frequency the |
->| | | | summarizing |
->| | | | iteration |
->| | | | output line |
->| | | | should be |
->| | | | printed. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_info_stri | OT_STRING | no | Enables |
->| ng | | | printing of |
->| | | | additional info |
->| | | | string at end |
->| | | | of iteration |
->| | | | output. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_level | OT_INTEGER | 5 | Output |
->| | | | verbosity |
->| | | | level. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_options_d | OT_STRING | no | Switch to print |
->| ocumentation | | | all algorithmic |
->| | | | options. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_options_l | OT_STRING | no | Undocumented |
->| atex_mode | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_time | OT_BOOLEAN | True | print |
->| | | | information |
->| | | | about execution |
->| | | | time |
->+-----------------+-----------------+-----------------+-----------------+
->| print_timing_st | OT_STRING | no | Switch to print |
->| atistics | | | timing |
->| | | | statistics. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| print_user_opti | OT_STRING | no | Print all |
->| ons | | | options set by |
->| | | | the user. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| quality_functio | OT_STRING | none | The balancing |
->| n_balancing_ter | | | term included |
->| m | | | in the quality |
->| | | | function for |
->| | | | centrality. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| quality_functio | OT_STRING | none | The penalty |
->| n_centrality | | | term for |
->| | | | centrality that |
->| | | | is included in |
->| | | | quality |
->| | | | function. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| quality_functio | OT_INTEGER | 8 | Maximum number |
->| n_max_section_s | | | of search steps |
->| teps | | | during direct |
->| | | | search |
->| | | | procedure |
->| | | | determining the |
->| | | | optimal |
->| | | | centering |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| quality_functio | OT_STRING | 2-norm-squared | Norm used for |
->| n_norm_type | | | components of |
->| | | | the quality |
->| | | | function. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| quality_functio | OT_REAL | 0 | Tolerance for |
->| n_section_qf_to | | | the golden |
->| l | | | section search |
->| | | | procedure |
->| | | | determining the |
->| | | | optimal |
->| | | | centering |
->| | | | parameter (in |
->| | | | the function |
->| | | | value space). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| quality_functio | OT_REAL | 0.010 | Tolerance for |
->| n_section_sigma | | | the section |
->| _tol | | | search |
->| | | | procedure |
->| | | | determining the |
->| | | | optimal |
->| | | | centering |
->| | | | parameter (in |
->| | | | sigma space). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| recalc_y | OT_STRING | no | Tells the |
->| | | | algorithm to |
->| | | | recalculate the |
->| | | | equality and |
->| | | | inequality |
->| | | | multipliers as |
->| | | | least square |
->| | | | estimates. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| recalc_y_feas_t | OT_REAL | 0.000 | Feasibility |
->| ol | | | threshold for |
->| | | | recomputation |
->| | | | of multipliers. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| replace_bounds | OT_STRING | no | Indicates if |
->| | | | all variable |
->| | | | bounds should |
->| | | | be replaced by |
->| | | | inequality |
->| | | | constraints |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| required_infeas | OT_REAL | 0.900 | Required |
->| ibility_reducti | | | reduction of |
->| on | | | infeasibility |
->| | | | before leaving |
->| | | | restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| residual_improv | OT_REAL | 1.000 | Minimal |
->| ement_factor | | | required |
->| | | | reduction of |
->| | | | residual test |
->| | | | ratio in |
->| | | | iterative |
->| | | | refinement. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| residual_ratio_ | OT_REAL | 0.000 | Iterative |
->| max | | | refinement |
->| | | | tolerance (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| residual_ratio_ | OT_REAL | 0.000 | Threshold for |
->| singular | | | declaring |
->| | | | linear system |
->| | | | singular after |
->| | | | failed |
->| | | | iterative |
->| | | | refinement. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| resto_failure_f | OT_REAL | 0 | Threshold for |
->| easibility_thre | | | primal |
->| shold | | | infeasibility |
->| | | | to declare |
->| | | | failure of |
->| | | | restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| resto_penalty_p | OT_REAL | 1000 | Penalty |
->| arameter | | | parameter in |
->| | | | the restoration |
->| | | | phase objective |
->| | | | function. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| resto_proximity | OT_REAL | 1 | Weighting |
->| _weight | | | factor for the |
->| | | | proximity term |
->| | | | in restoration |
->| | | | phase |
->| | | | objective. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| rho | OT_REAL | 0.100 | Value in |
->| | | | penalty |
->| | | | parameter |
->| | | | update formula. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| s_max | OT_REAL | 100 | Scaling |
->| | | | threshold for |
->| | | | the NLP error. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| s_phi | OT_REAL | 2.300 | Exponent for |
->| | | | linear barrier |
->| | | | function model |
->| | | | in the |
->| | | | switching rule. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| s_theta | OT_REAL | 1.100 | Exponent for |
->| | | | current |
->| | | | constraint |
->| | | | violation in |
->| | | | the switching |
->| | | | rule. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| sb | OT_STRING | no | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| sigma_max | OT_REAL | 100 | Maximum value |
->| | | | of the |
->| | | | centering |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| sigma_min | OT_REAL | 0.000 | Minimum value |
->| | | | of the |
->| | | | centering |
->| | | | parameter. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| skip_corr_if_ne | OT_STRING | yes | Skip the |
->| g_curv | | | corrector step |
->| | | | in negative |
->| | | | curvature |
->| | | | iteration |
->| | | | (unsupported!). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| skip_corr_in_mo | OT_STRING | yes | Skip the |
->| notone_mode | | | corrector step |
->| | | | during monotone |
->| | | | barrier |
->| | | | parameter mode |
->| | | | (unsupported!). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| skip_finalize_s | OT_STRING | no | Indicates if |
->| olution_call | | | call to NLP::Fi |
->| | | | nalizeSolution |
->| | | | after |
->| | | | optimization |
->| | | | should be |
->| | | | suppressed (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| slack_bound_fra | OT_REAL | 0.010 | Desired minimum |
->| c | | | relative |
->| | | | distance from |
->| | | | the initial |
->| | | | slack to bound. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| slack_bound_pus | OT_REAL | 0.010 | Desired minimum |
->| h | | | absolute |
->| | | | distance from |
->| | | | the initial |
->| | | | slack to bound. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| slack_move | OT_REAL | 0.000 | Correction size |
->| | | | for very small |
->| | | | slacks. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| soft_resto_pder | OT_REAL | 1.000 | Required |
->| ror_reduction_f | | | reduction in |
->| actor | | | primal-dual |
->| | | | error in the |
->| | | | soft |
->| | | | restoration |
->| | | | phase. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| start_with_rest | OT_STRING | no | Tells algorithm |
->| o | | | to switch to |
->| | | | restoration |
->| | | | phase in first |
->| | | | iteration. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| suppress_all_ou | OT_STRING | no | Undocumented |
->| tput | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| tau_min | OT_REAL | 0.990 | Lower bound on |
->| | | | fraction-to- |
->| | | | the-boundary |
->| | | | parameter tau. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| theta_max_fact | OT_REAL | 10000 | Determines |
->| | | | upper bound for |
->| | | | constraint |
->| | | | violation in |
->| | | | the filter. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| theta_min | OT_REAL | 0.000 | LIFENG WRITES |
->| | | | THIS. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| theta_min_fact | OT_REAL | 0.000 | Determines |
->| | | | constraint |
->| | | | violation |
->| | | | threshold in |
->| | | | the switching |
->| | | | rule. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| tiny_step_tol | OT_REAL | 0.000 | Tolerance for |
->| | | | detecting |
->| | | | numerically |
->| | | | insignificant |
->| | | | steps. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| tiny_step_y_tol | OT_REAL | 0.010 | Tolerance for |
->| | | | quitting |
->| | | | because of |
->| | | | numerically |
->| | | | insignificant |
->| | | | steps. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| tol | OT_REAL | 0.000 | Desired |
->| | | | convergence |
->| | | | tolerance |
->| | | | (relative). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| var_integer_md | OT_DICTIONARY | None | Integer |
->| | | | metadata (a |
->| | | | dictionary with |
->| | | | lists of |
->| | | | integers) about |
->| | | | variables to be |
->| | | | passed to IPOPT |
->+-----------------+-----------------+-----------------+-----------------+
->| var_numeric_md | OT_DICTIONARY | None | Numeric |
->| | | | metadata (a |
->| | | | dictionary with |
->| | | | lists of reals) |
->| | | | about variables |
->| | | | to be passed to |
->| | | | IPOPT |
->+-----------------+-----------------+-----------------+-----------------+
->| var_string_md | OT_DICTIONARY | None | String metadata |
->| | | | (a dictionary |
->| | | | with lists of |
->| | | | strings) about |
->| | | | variables to be |
->| | | | passed to IPOPT |
->+-----------------+-----------------+-----------------+-----------------+
->| vartheta | OT_REAL | 0.500 | a parameter |
->| | | | used to check |
->| | | | if the fast |
->| | | | direction can |
->| | | | be used asthe |
->| | | | line search |
->| | | | direction (for |
->| | | | Chen-Goldfarb |
->| | | | line search). |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_boun | OT_REAL | 0.001 | same as |
->| d_frac | | | bound_frac for |
->| | | | the regular |
->| | | | initializer. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_boun | OT_REAL | 0.001 | same as |
->| d_push | | | bound_push for |
->| | | | the regular |
->| | | | initializer. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_enti | OT_STRING | no | Tells algorithm |
->| re_iterate | | | whether to use |
->| | | | the GetWarmStar |
->| | | | tIterate method |
->| | | | in the NLP. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_init | OT_STRING | no | Warm-start for |
->| _point | | | initial point |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_mult | OT_REAL | 0.001 | same as |
->| _bound_push | | | mult_bound_push |
->| | | | for the regular |
->| | | | initializer. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_mult | OT_REAL | 1000000 | Maximum initial |
->| _init_max | | | value for the |
->| | | | equality |
->| | | | multipliers. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_same | OT_STRING | no | Indicates |
->| _structure | | | whether a |
->| | | | problem with a |
->| | | | structure |
->| | | | identical to |
->| | | | the previous |
->| | | | one is to be |
->| | | | solved. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_slac | OT_REAL | 0.001 | same as slack_b |
->| k_bound_frac | | | ound_frac for |
->| | | | the regular |
->| | | | initializer. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_slac | OT_REAL | 0.001 | same as slack_b |
->| k_bound_push | | | ound_push for |
->| | | | the regular |
->| | | | initializer. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start_targ | OT_REAL | 0 | Unsupported! |
->| et_mu | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| watchdog_shorte | OT_INTEGER | 10 | Number of |
->| ned_iter_trigge | | | shortened |
->| r | | | iterations that |
->| | | | trigger the |
->| | | | watchdog. (see |
->| | | | IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| watchdog_trial_ | OT_INTEGER | 3 | Maximum number |
->| iter_max | | | of watchdog |
->| | | | iterations. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->| wsmp_iterative | OT_STRING | no | Switches to |
->| | | | iterative |
->| | | | solver in WSMP. |
->| | | | (see IPOPT |
->| | | | documentation) |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-------------+
->| Id |
->+=============+
->| eval_f |
->+-------------+
->| eval_g |
->+-------------+
->| eval_grad_f |
->+-------------+
->| eval_h |
->+-------------+
->| eval_jac_g |
->+-------------+
->
->>List of available stats
->
->+--------------------+
->| Id |
->+====================+
->| con_integer_md |
->+--------------------+
->| con_numeric_md |
->+--------------------+
->| con_string_md |
->+--------------------+
->| iter_count |
->+--------------------+
->| iteration |
->+--------------------+
->| iterations |
->+--------------------+
->| n_eval_f |
->+--------------------+
->| n_eval_g |
->+--------------------+
->| n_eval_grad_f |
->+--------------------+
->| n_eval_h |
->+--------------------+
->| n_eval_jac_g |
->+--------------------+
->| return_status |
->+--------------------+
->| t_callback_fun |
->+--------------------+
->| t_callback_prepare |
->+--------------------+
->| t_eval_f |
->+--------------------+
->| t_eval_g |
->+--------------------+
->| t_eval_grad_f |
->+--------------------+
->| t_eval_h |
->+--------------------+
->| t_eval_jac_g |
->+--------------------+
->| t_mainloop |
->+--------------------+
->| var_integer_md |
->+--------------------+
->| var_numeric_md |
->+--------------------+
->| var_string_md |
->+--------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->knitro
->------
->
->
->
->KNITRO interface
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| BarRule | OT_INTEGER | 0 | Barrier Rule |
->+-----------------+-----------------+-----------------+-----------------+
->| Debug | OT_INTEGER | 0 | Debug level |
->+-----------------+-----------------+-----------------+-----------------+
->| Delta | OT_REAL | 1 | Initial region |
->| | | | scaling factor |
->+-----------------+-----------------+-----------------+-----------------+
->| FeasModeTol | OT_REAL | 0.000 | Feasible mode |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| FeasTol | OT_REAL | 0.000 | Feasible |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| FeasTolAbs | OT_REAL | 1 | Absolute |
->| | | | feasible |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| Feasible | OT_BOOLEAN | 0 | Allow |
->| | | | infeasible |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| GradOpt | OT_INTEGER | 1 | Gradient |
->| | | | calculation |
->| | | | method |
->+-----------------+-----------------+-----------------+-----------------+
->| HessOpt | OT_INTEGER | 1 | Hessian |
->| | | | calculation |
->| | | | method |
->+-----------------+-----------------+-----------------+-----------------+
->| HonorBnds | OT_BOOLEAN | 0 | Enforce bounds |
->+-----------------+-----------------+-----------------+-----------------+
->| InitPt | OT_BOOLEAN | 0 | Use initial |
->| | | | point strategy |
->+-----------------+-----------------+-----------------+-----------------+
->| LmSize | OT_INTEGER | 10 | Memory pairsize |
->| | | | limit |
->+-----------------+-----------------+-----------------+-----------------+
->| LpSolver | OT_BOOLEAN | 0 | Use LpSolver |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxCgIt | OT_INTEGER | 0 | Maximum |
->| | | | conjugate |
->| | | | gradient |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxIt | OT_INTEGER | 10000 | Iteration limit |
->+-----------------+-----------------+-----------------+-----------------+
->| Mu | OT_REAL | 0.100 | Initial barrier |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| Multistart | OT_BOOLEAN | 0 | Use multistart |
->+-----------------+-----------------+-----------------+-----------------+
->| NewPoint | OT_BOOLEAN | 0 | Select new- |
->| | | | point feature |
->+-----------------+-----------------+-----------------+-----------------+
->| ObjRange | OT_REAL | 0.000 | Maximum |
->| | | | objective value |
->+-----------------+-----------------+-----------------+-----------------+
->| OptTol | OT_REAL | 0.000 | Relative |
->| | | | optimality |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| OptTolAbs | OT_REAL | 0 | Absolute |
->| | | | optimality |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| OutLev | OT_INTEGER | 2 | Log output |
->| | | | level |
->+-----------------+-----------------+-----------------+-----------------+
->| Pivot | OT_REAL | 0.000 | Initial pivot |
->| | | | threshold |
->+-----------------+-----------------+-----------------+-----------------+
->| Scale | OT_BOOLEAN | 1 | Perform scaling |
->+-----------------+-----------------+-----------------+-----------------+
->| ShiftInit | OT_BOOLEAN | 1 | Interior-point |
->| | | | shifting |
->| | | | initial point |
->+-----------------+-----------------+-----------------+-----------------+
->| Soc | OT_INTEGER | 1 | Second order |
->| | | | correction |
->+-----------------+-----------------+-----------------+-----------------+
->| XTol | OT_REAL | 0.000 | Relative |
->| | | | solution change |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| contype | OT_INTEGERVECTO | | |
->| | R | | |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-------------+
->| Id |
->+=============+
->| eval_f |
->+-------------+
->| eval_g |
->+-------------+
->| eval_grad_f |
->+-------------+
->| eval_h |
->+-------------+
->| eval_jac_g |
->+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->snopt
->-----
->
->
->
->SNOPT interface
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| _feasibility_to | OT_REAL | None | Feasibility |
->| lerance | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| _iprint | OT_INTEGER | 0 | n/a |
->+-----------------+-----------------+-----------------+-----------------+
->| _isumm | OT_INTEGER | 6 | n/a |
->+-----------------+-----------------+-----------------+-----------------+
->| _major_iteratio | OT_INTEGER | None | Major iteration |
->| n_limit | | | limit |
->+-----------------+-----------------+-----------------+-----------------+
->| _minor_iteratio | OT_INTEGER | None | Minor iteration |
->| n_limit | | | limit |
->+-----------------+-----------------+-----------------+-----------------+
->| _optimality_tol | OT_REAL | None | Optimality |
->| erance | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| _scale_option | OT_INTEGER | None | Scale option |
->+-----------------+-----------------+-----------------+-----------------+
->| _start | OT_STRING | Cold | |
->+-----------------+-----------------+-----------------+-----------------+
->| _verify_level | OT_INTEGER | None | Verify level |
->+-----------------+-----------------+-----------------+-----------------+
->| detect_linear | OT_BOOLEAN | True | Make an effort |
->| | | | to treat linear |
->| | | | constraints and |
->| | | | linear |
->| | | | variables |
->| | | | specially. |
->+-----------------+-----------------+-----------------+-----------------+
->| print_time | OT_BOOLEAN | True | print |
->| | | | information |
->| | | | about execution |
->| | | | time |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-----------+
->| Id |
->+===========+
->| eval_nlp |
->+-----------+
->| setup_nlp |
->+-----------+
->
->>List of available stats
->
->+----------------+
->| Id |
->+================+
->| iter_count |
->+----------------+
->| iterations |
->+----------------+
->| n_callback_fun |
->+----------------+
->| n_eval_grad_f |
->+----------------+
->| n_eval_jac_g |
->+----------------+
->| return_status |
->+----------------+
->| t_callback_fun |
->+----------------+
->| t_eval_grad_f |
->+----------------+
->| t_eval_jac_g |
->+----------------+
->| t_mainloop |
->+----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->worhp
->-----
->
->
->
->WORHP interface
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| AcceptTolFeas | OT_REAL | 0.001 | Tolerance for |
->| | | | acceptable |
->| | | | feasibility |
->+-----------------+-----------------+-----------------+-----------------+
->| AcceptTolOpti | OT_REAL | 0.001 | Tolerance for |
->| | | | acceptable |
->| | | | optimality |
->+-----------------+-----------------+-----------------+-----------------+
->| AlphaMinConst | OT_BOOLEAN | False | Use a constant |
->| | | | lower bound on |
->| | | | Armijo stepsize |
->| | | | in Filter |
->+-----------------+-----------------+-----------------+-----------------+
->| Ares | OT_INTEGERVECTO | [42, 41, 42, | Armijo recovery |
->| | R | 43, 44, 41, 50] | strategies. |
->| | | | Vector of size |
->| | | | 7 |
->+-----------------+-----------------+-----------------+-----------------+
->| ArmijoBeta | OT_REAL | 0.712 | Trial stepsize |
->| | | | decrease factor |
->| | | | for Armijo rule |
->+-----------------+-----------------+-----------------+-----------------+
->| ArmijoMaxAlpha | OT_REAL | 1 | Initial alpha |
->| | | | for Armijo rule |
->+-----------------+-----------------+-----------------+-----------------+
->| ArmijoMinAlpha | OT_REAL | 0.000 | Lower bound on |
->| | | | alpha for |
->| | | | Armijo rule |
->+-----------------+-----------------+-----------------+-----------------+
->| ArmijoMinAlphaR | OT_REAL | 0.000 | Lower bound on |
->| ec | | | alpha for |
->| | | | Armijo rule |
->| | | | during recovery |
->+-----------------+-----------------+-----------------+-----------------+
->| ArmijoSigma | OT_REAL | 0.005 | Scale factor |
->| | | | for linearised |
->| | | | descent check |
->| | | | in Armijo rule |
->+-----------------+-----------------+-----------------+-----------------+
->| AutoQPRecovery | OT_BOOLEAN | True | Enable |
->| | | | automatic QP |
->| | | | recovery |
->+-----------------+-----------------+-----------------+-----------------+
->| BFGSmaxblockSiz | OT_INTEGER | 300 | Block size |
->| e | | | parameter used |
->| | | | by certain BFGS |
->| | | | methods |
->+-----------------+-----------------+-----------------+-----------------+
->| BFGSmethod | OT_INTEGER | 0 | Choose BFGS |
->| | | | method (0: |
->| | | | dense, 1-3: |
->| | | | block, 100+: |
->| | | | sparse) |
->+-----------------+-----------------+-----------------+-----------------+
->| BFGSminblockSiz | OT_INTEGER | 300 | Block size |
->| e | | | parameter used |
->| | | | by certain BFGS |
->| | | | methods |
->+-----------------+-----------------+-----------------+-----------------+
->| BFGSrestart | OT_INTEGER | 50 | Restart BFGS |
->| | | | update after |
->| | | | this many |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| BettsFactor | OT_REAL | 2.100 | Update factor |
->| | | | for Betts' |
->| | | | Hessian |
->| | | | regularisation |
->+-----------------+-----------------+-----------------+-----------------+
->| BettsPoint | OT_REAL | 1 | Smallest |
->| | | | eigenvalue of |
->| | | | the regularised |
->| | | | Hessian |
->+-----------------+-----------------+-----------------+-----------------+
->| BoundTolFac | OT_REAL | 1000 | Factor in |
->| | | | determining |
->| | | | active |
->| | | | constraints by |
->| | | | KKT |
->+-----------------+-----------------+-----------------+-----------------+
->| CheckFJ | OT_REAL | 1.000e+12 | Upper bound |
->| | | | used by Fritz- |
->| | | | John heuristic |
->+-----------------+-----------------+-----------------+-----------------+
->| CheckStructureD | OT_BOOLEAN | True | Enable |
->| F | | | structural |
->| | | | checking of DF |
->+-----------------+-----------------+-----------------+-----------------+
->| CheckStructureD | OT_BOOLEAN | True | Enable |
->| G | | | structural |
->| | | | checking of DG |
->+-----------------+-----------------+-----------------+-----------------+
->| CheckStructureH | OT_BOOLEAN | True | Enable |
->| M | | | structural |
->| | | | checking of HM |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepBettsSum | OT_REAL | 0.500 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepConStop | OT_REAL | 0.000 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepConvio | OT_REAL | 1 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepMaxIter | OT_INTEGER | 50 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepMethod | OT_INTEGER | 0 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepMode | OT_INTEGER | 1 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepPFactor | OT_REAL | 1 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepPMax | OT_REAL | 1000000 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| CorStepRecovery | OT_BOOLEAN | False | (experimental) |
->| DX | | | |
->+-----------------+-----------------+-----------------+-----------------+
->| CurvBCond | OT_REAL | 0.020 | Block BFGS |
->| | | | curvature |
->| | | | condition bound |
->+-----------------+-----------------+-----------------+-----------------+
->| CurvBFac | OT_REAL | 0.300 | Block BFGS |
->| | | | curvature |
->| | | | condition |
->| | | | regularisation |
->| | | | factor |
->+-----------------+-----------------+-----------------+-----------------+
->| CurvCond | OT_REAL | 0.020 | BFGS Curvature |
->| | | | condition bound |
->+-----------------+-----------------+-----------------+-----------------+
->| CurvFac | OT_REAL | 0.300 | BFGS curvature |
->| | | | condition |
->| | | | regularisation |
->| | | | factor |
->+-----------------+-----------------+-----------------+-----------------+
->| DebugMarker05 | OT_INTEGER | 42 | Debug marker. |
->| | | | Used to find |
->| | | | memory alignmen |
->| | | | t/padding |
->| | | | issues |
->+-----------------+-----------------+-----------------+-----------------+
->| DebugMarker06 | OT_INTEGER | 42 | Debug marker. |
->| | | | Used to find |
->| | | | memory alignmen |
->| | | | t/padding |
->| | | | issues |
->+-----------------+-----------------+-----------------+-----------------+
->| FGtogether | OT_BOOLEAN | False | F and G cannot |
->| | | | be evaluated |
->| | | | separately |
->+-----------------+-----------------+-----------------+-----------------+
->| FJandND | OT_BOOLEAN | False | Enable Fritz- |
->| | | | John and non- |
->| | | | differentiable |
->| | | | check |
->| | | | heuristics |
->+-----------------+-----------------+-----------------+-----------------+
->| FeasibleDual | OT_BOOLEAN | False | Activate dual |
->| | | | feasibility |
->| | | | mode |
->+-----------------+-----------------+-----------------+-----------------+
->| FeasibleInit | OT_BOOLEAN | False | Activate |
->| | | | initial |
->| | | | feasibility |
->| | | | mode |
->+-----------------+-----------------+-----------------+-----------------+
->| FeasibleInitTol | OT_REAL | 0.001 | Feasibility |
->| | | | tolerance for |
->| | | | no-objective |
->| | | | feasible mode |
->+-----------------+-----------------+-----------------+-----------------+
->| FeasibleOnly | OT_BOOLEAN | False | Activate |
->| | | | feasible-only |
->| | | | mode |
->+-----------------+-----------------+-----------------+-----------------+
->| FidifEps | OT_REAL | 0.000 | Finite |
->| | | | difference |
->| | | | perturbation |
->+-----------------+-----------------+-----------------+-----------------+
->| FidifHM | OT_BOOLEAN | False | Approximate |
->| | | | Hessian by |
->| | | | finite |
->| | | | differences |
->| | | | (otherwise |
->| | | | BFGS) |
->+-----------------+-----------------+-----------------+-----------------+
->| FilterBisecAlph | OT_BOOLEAN | True | Filter |
->| a | | | heuristic to |
->| | | | save Armijo |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| FilterGammaCV | OT_REAL | 0.000 | Constraint |
->| | | | violation |
->| | | | decrease factor |
->| | | | in Filter |
->| | | | acceptance |
->| | | | check |
->+-----------------+-----------------+-----------------+-----------------+
->| FilterGammaF | OT_REAL | 0.000 | Objective |
->| | | | decrease factor |
->| | | | in Filter |
->| | | | acceptance |
->| | | | check |
->+-----------------+-----------------+-----------------+-----------------+
->| FilterIntersecA | OT_BOOLEAN | True | Filter |
->| lpha | | | heuristic to |
->| | | | save Armijo |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| FirstDifCentral | OT_BOOLEAN | True | Use central |
->| | | | finite |
->| | | | difference |
->| | | | quotient for |
->| | | | first |
->| | | | derivatives |
->+-----------------+-----------------+-----------------+-----------------+
->| FocusOnFeas | OT_BOOLEAN | True | Enable Focus- |
->| | | | on-Feasibility |
->| | | | mode |
->+-----------------+-----------------+-----------------+-----------------+
->| FocusOnFeasFact | OT_REAL | 1.360 | Factor in |
->| or | | | Focus-on- |
->| | | | Feasibility |
->| | | | mode |
->+-----------------+-----------------+-----------------+-----------------+
->| GammaAlpha | OT_REAL | 0.050 | Safety factor |
->| | | | for alphamin |
->| | | | calculation by |
->| | | | Filter |
->+-----------------+-----------------+-----------------+-----------------+
->| GroupMethod | OT_INTEGER | 1 | Select method |
->| | | | to determine |
->| | | | graph colouring |
->| | | | groups |
->+-----------------+-----------------+-----------------+-----------------+
->| IgnoreFilterCri | OT_BOOLEAN | False | Activate |
->| t | | | accelerating |
->| | | | heuristics for |
->| | | | Filter |
->+-----------------+-----------------+-----------------+-----------------+
->| IncBettsTau | OT_REAL | 2 | Increase factor |
->| | | | for Betts' |
->| | | | update |
->| | | | dampening term |
->+-----------------+-----------------+-----------------+-----------------+
->| IncBettsTauMore | OT_REAL | 100 | Larger increase |
->| | | | factor for |
->| | | | Betts' update |
->| | | | dampening term |
->+-----------------+-----------------+-----------------+-----------------+
->| IncreaseIWS | OT_REAL | 1 | Increase factor |
->| | | | for estimated |
->| | | | integer |
->| | | | workspace |
->| | | | requirement |
->+-----------------+-----------------+-----------------+-----------------+
->| IncreaseRWS | OT_REAL | 1 | Increase factor |
->| | | | for estimated |
->| | | | real workspace |
->| | | | requirement |
->+-----------------+-----------------+-----------------+-----------------+
->| Infty | OT_REAL | 1.000e+20 | Upper bound for |
->| | | | numbers to be |
->| | | | regarded as |
->| | | | finite |
->+-----------------+-----------------+-----------------+-----------------+
->| InftyUnbounded | OT_REAL | 1.000e+20 | Tolerance for |
->| | | | unboundedness |
->| | | | detection |
->| | | | heuristic |
->+-----------------+-----------------+-----------------+-----------------+
->| InitialLMest | OT_BOOLEAN | True | Enable initial |
->| | | | Lagrange |
->| | | | multiplier |
->| | | | estimate |
->+-----------------+-----------------+-----------------+-----------------+
->| KeepAcceptableS | OT_BOOLEAN | True | Save acceptable |
->| ol | | | solutions as |
->| | | | fallback |
->+-----------------+-----------------+-----------------+-----------------+
->| LMestQPipComTol | OT_REAL | 0.003 | IP |
->| | | | complementarity |
->| | | | tolerance in |
->| | | | initial |
->| | | | multiplier |
->| | | | estimate |
->+-----------------+-----------------+-----------------+-----------------+
->| LMestQPipResTol | OT_REAL | 1 | IP residual |
->| | | | tolerance in |
->| | | | initial |
->| | | | multiplier |
->| | | | estimate |
->+-----------------+-----------------+-----------------+-----------------+
->| LinMult | OT_BOOLEAN | False | Control |
->| | | | Lagrange |
->| | | | multiplier |
->| | | | update |
->+-----------------+-----------------+-----------------+-----------------+
->| LogLevel | OT_INTEGER | 0 | Enable XML |
->| | | | logfiles and |
->| | | | writing |
->| | | | interval |
->+-----------------+-----------------+-----------------+-----------------+
->| LogResult | OT_INTEGER | 0 | Enable XML |
->| | | | result logging |
->| | | | and detail |
->| | | | level |
->+-----------------+-----------------+-----------------+-----------------+
->| LowPassAlphaF | OT_REAL | 0.950 | Lowpass-filter |
->| | | | update factor |
->| | | | for objective |
->| | | | values |
->+-----------------+-----------------+-----------------+-----------------+
->| LowPassAlphaG | OT_REAL | 0.950 | Lowpass-filter |
->| | | | update factor |
->| | | | for constraint |
->| | | | values |
->+-----------------+-----------------+-----------------+-----------------+
->| LowPassAlphaMer | OT_REAL | 0.100 | Lowpass-filter |
->| it | | | update factor |
->| | | | for merit |
->| | | | function values |
->+-----------------+-----------------+-----------------+-----------------+
->| LowPassFilter | OT_BOOLEAN | True | Enable lowpass- |
->| | | | filter |
->| | | | termination |
->| | | | criterion |
->+-----------------+-----------------+-----------------+-----------------+
->| MAPivotThreshol | OT_REAL | 0.000 | Pivoting |
->| d | | | tolerance for |
->| | | | MA solvers |
->+-----------------+-----------------+-----------------+-----------------+
->| MatrixCC | OT_BOOLEAN | False | Not to be |
->| | | | included into a |
->| | | | parameter file! |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxCalls | OT_INTEGER | 2.147e+09 | Upper bound to |
->| | | | Reverse |
->| | | | Communication |
->| | | | calls |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxForce | OT_INTEGER | 1000 | Maximum number |
->| | | | of Force |
->| | | | recovery |
->| | | | strategy steps |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxGPart | OT_INTEGER | 1 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxIter | OT_INTEGER | 500 | Upper bound on |
->| | | | major |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxLScounter | OT_INTEGER | 3 | Control |
->| | | | activation of |
->| | | | Filter |
->| | | | acceleration |
->| | | | heuristics |
->+-----------------+-----------------+-----------------+-----------------+
->| MaxNorm | OT_BOOLEAN | True | Select max-norm |
->| | | | instead of |
->| | | | 1-norm in |
->| | | | Filter |
->+-----------------+-----------------+-----------------+-----------------+
->| MeritFunction | OT_INTEGER | 4 | Select merit |
->| | | | function and |
->| | | | penalty update |
->| | | | [0, 3..5] |
->+-----------------+-----------------+-----------------+-----------------+
->| MeritGradTol | OT_REAL | 0.000 | Threshold of |
->| | | | meritfunction |
->| | | | gradient for |
->| | | | increasing |
->| | | | Hessian |
->| | | | regularisation |
->+-----------------+-----------------+-----------------+-----------------+
->| MinBettsTau | OT_REAL | 0.000 | Lower bound for |
->| | | | Betts' update |
->| | | | dampening term |
->+-----------------+-----------------+-----------------+-----------------+
->| MoreRelax | OT_BOOLEAN | False | Introduce one |
->| | | | relaxation |
->| | | | variable for |
->| | | | every |
->| | | | constraint |
->+-----------------+-----------------+-----------------+-----------------+
->| NLPmethod | OT_INTEGER | 1 | Select (1) |
->| | | | Meritfunction |
->| | | | or (3) Filter |
->| | | | globalisation |
->+-----------------+-----------------+-----------------+-----------------+
->| NLPprint | OT_INTEGER | 2 | NLP print level |
->| | | | [-1..4] |
->+-----------------+-----------------+-----------------+-----------------+
->| PairMethod | OT_INTEGER | 1 | Select method |
->| | | | to determine |
->| | | | graph colouring |
->| | | | pairgroups |
->+-----------------+-----------------+-----------------+-----------------+
->| PenUpdEpsBar | OT_REAL | 0.900 | Penalty update |
->| | | | parameter |
->| | | | factor for |
->| | | | MeritFunction = |
->| | | | 3 |
->+-----------------+-----------------+-----------------+-----------------+
->| PenUpdEpsKFac | OT_REAL | 2 | Penalty update |
->| | | | parameter |
->| | | | factor for |
->| | | | MeritFunction = |
->| | | | 4 |
->+-----------------+-----------------+-----------------+-----------------+
->| PenUpdEpsKSeque | OT_INTEGER | 2 | Penalty update |
->| nce | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| PenUpdMaxDeltaK | OT_REAL | 11 | Max penalty for |
->| | | | MeritFunction = |
->| | | | 4 |
->+-----------------+-----------------+-----------------+-----------------+
->| PenUpdMaxFac | OT_REAL | 100000000 | Max factor for |
->| | | | increasing |
->| | | | penalty for |
->| | | | MeritFunction = |
->| | | | 4 |
->+-----------------+-----------------+-----------------+-----------------+
->| PenUpdRBar | OT_REAL | 2 | Penalty update |
->| | | | parameter for |
->| | | | MeritFunction = |
->| | | | 3 |
->+-----------------+-----------------+-----------------+-----------------+
->| PrecisionF | OT_REAL | 0.000 | (currently |
->| | | | unused) |
->| | | | Relative |
->| | | | precision of |
->| | | | objective |
->+-----------------+-----------------+-----------------+-----------------+
->| PrecisionG | OT_REAL | 0.000 | (currently |
->| | | | unused) |
->| | | | Relative |
->| | | | precision of |
->| | | | constraints |
->+-----------------+-----------------+-----------------+-----------------+
->| QPscaleParam | OT_REAL | 0 | (currently |
->| | | | unused) Scaling |
->| | | | factor for QP |
->+-----------------+-----------------+-----------------+-----------------+
->| QuadraticProble | OT_BOOLEAN | False | Not to be |
->| m | | | included into a |
->| | | | parameter file! |
->+-----------------+-----------------+-----------------+-----------------+
->| ReduceBettsTau | OT_REAL | 0.300 | Decrease factor |
->| | | | for Betts' |
->| | | | update |
->| | | | dampening term |
->+-----------------+-----------------+-----------------+-----------------+
->| RegStrategy | OT_INTEGER | 1 | Select Hessian |
->| | | | regularisation |
->| | | | strategy in |
->| | | | Filter |
->+-----------------+-----------------+-----------------+-----------------+
->| ReinitFilter | OT_BOOLEAN | False | Enables Filter- |
->| | | | reinitialisatio |
->| | | | n accelerating |
->| | | | heuristic |
->+-----------------+-----------------+-----------------+-----------------+
->| RelaxMaxDelta | OT_REAL | 0.920 | Upper bound for |
->| | | | accepting the |
->| | | | constraint |
->| | | | relaxation |
->| | | | variable |
->+-----------------+-----------------+-----------------+-----------------+
->| RelaxMaxPen | OT_REAL | 50000000 | Upper bound on |
->| | | | the constraint |
->| | | | relaxation |
->| | | | penalty |
->+-----------------+-----------------+-----------------+-----------------+
->| RelaxRho | OT_REAL | 6 | Update factor |
->| | | | for the |
->| | | | constraint |
->| | | | relaxation |
->| | | | penalty |
->+-----------------+-----------------+-----------------+-----------------+
->| RelaxStart | OT_REAL | 1 | Initial value |
->| | | | of the |
->| | | | constraint |
->| | | | relaxation |
->| | | | penalty |
->+-----------------+-----------------+-----------------+-----------------+
->| RestUntilFeas | OT_BOOLEAN | False | Do restoration |
->| | | | until a |
->| | | | feasible |
->| | | | solution is |
->| | | | found |
->+-----------------+-----------------+-----------------+-----------------+
->| ScaleConIter | OT_BOOLEAN | False | Scale |
->| | | | constraints in |
->| | | | every iteration |
->+-----------------+-----------------+-----------------+-----------------+
->| ScaleFacObj | OT_REAL | 10 | Value to scale |
->| | | | large objective |
->| | | | functions to |
->+-----------------+-----------------+-----------------+-----------------+
->| ScaleFacQP | OT_REAL | 10 | Upper bound on |
->| | | | resulting |
->| | | | matrix norm for |
->| | | | QP scaling |
->+-----------------+-----------------+-----------------+-----------------+
->| ScaledFD | OT_BOOLEAN | True | Use a scaled |
->| | | | perturbation |
->| | | | for finite |
->| | | | differences |
->+-----------------+-----------------+-----------------+-----------------+
->| ScaledKKT | OT_BOOLEAN | True | Scale KKT |
->| | | | conditions |
->+-----------------+-----------------+-----------------+-----------------+
->| ScaledObj | OT_BOOLEAN | True | Scale the |
->| | | | objective |
->| | | | function |
->+-----------------+-----------------+-----------------+-----------------+
->| ScaledQP | OT_BOOLEAN | True | Scale some |
->| | | | matrices handed |
->| | | | to the QP |
->+-----------------+-----------------+-----------------+-----------------+
->| StartBettsTau | OT_REAL | 0.100 | Initial value |
->| | | | for Betts' |
->| | | | update |
->| | | | dampening term |
->+-----------------+-----------------+-----------------+-----------------+
->| SwitchingDelta | OT_REAL | 0.010 | Filter |
->| | | | switching |
->| | | | condition |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| SwitchingSCV | OT_REAL | 1.100 | Filter |
->| | | | switching |
->| | | | condition |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| SwitchingSF | OT_REAL | 2.300 | Filter |
->| | | | switching |
->| | | | condition |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| TakeQPSol | OT_BOOLEAN | False | Evaluate QP |
->| | | | search |
->| | | | direction |
->| | | | regardless of |
->| | | | convergence |
->+-----------------+-----------------+-----------------+-----------------+
->| Timeout | OT_REAL | 300 | Timeout in |
->| | | | seconds |
->+-----------------+-----------------+-----------------+-----------------+
->| TolComp | OT_REAL | 0.001 | Complementarity |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| TolFeas | OT_REAL | 0.000 | Feasibility |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| TolOpti | OT_REAL | 0.000 | Optimality |
->| | | | tolerance |
->+-----------------+-----------------+-----------------+-----------------+
->| TolWeakActive | OT_REAL | 1 | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| TooBig | OT_BOOLEAN | True | Enable too-big |
->| | | | termination |
->| | | | heuristics |
->+-----------------+-----------------+-----------------+-----------------+
->| TooBigCV | OT_REAL | 1.000e+25 | Upper bound on |
->| | | | constraint |
->| | | | violation for |
->| | | | too-big |
->| | | | heuristic |
->+-----------------+-----------------+-----------------+-----------------+
->| TooBigKKT | OT_REAL | 1.000e+30 | Upper bound on |
->| | | | KKT values for |
->| | | | too-big |
->| | | | heuristic |
->+-----------------+-----------------+-----------------+-----------------+
->| UserDF | OT_BOOLEAN | True | Objective |
->| | | | gradient values |
->| | | | supplied by |
->| | | | caller |
->+-----------------+-----------------+-----------------+-----------------+
->| UserDG | OT_BOOLEAN | True | Jacobian values |
->| | | | supplied by |
->| | | | caller |
->+-----------------+-----------------+-----------------+-----------------+
->| UserHM | OT_BOOLEAN | True | Hessian values |
->| | | | supplied by |
->| | | | caller |
->+-----------------+-----------------+-----------------+-----------------+
->| UserHMstructure | OT_INTEGER | 2 | Enable |
->| | | | automatic |
->| | | | Hessian |
->| | | | structure |
->| | | | generation or |
->| | | | checking |
->+-----------------+-----------------+-----------------+-----------------+
->| WeakActiveSet | OT_BOOLEAN | False | (experimental) |
->+-----------------+-----------------+-----------------+-----------------+
->| eps | OT_REAL | 0.000 | Machine epsilon |
->+-----------------+-----------------+-----------------+-----------------+
->| internalParChan | OT_INTEGER | 0 | Counter for |
->| ged | | | changed |
->| | | | parameters. |
->| | | | Internal use |
->| | | | only. |
->+-----------------+-----------------+-----------------+-----------------+
->| print_time | OT_BOOLEAN | True | Print |
->| | | | information |
->| | | | about execution |
->| | | | time |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipBarrier | OT_REAL | 7.800 | IP barrier |
->| | | | parameter. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipComTol | OT_REAL | 0.000 | IP |
->| | | | complementarity |
->| | | | tolerance. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipFracBound | OT_REAL | 0.880 | IP fraction-to- |
->| | | | the-boundary |
->| | | | parameter. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipLsMethod | OT_STRING | None | Select the |
->| | | | direct linear |
->| | | | solver used by |
->| | | | the IP method. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipMinAlpha | OT_REAL | 0.000 | IP line search |
->| | | | minimum step |
->| | | | size. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipRelaxDiv | OT_REAL | 2 | The relaxation |
->| | | | term is divided |
->| | | | by this value |
->| | | | if successful. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipRelaxMax | OT_REAL | 0.000 | Maximum |
->| | | | relaxation |
->| | | | value. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipRelaxMin | OT_REAL | 0.000 | Mimimum |
->| | | | relaxation |
->| | | | value. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipRelaxMult | OT_REAL | 10 | The relaxation |
->| | | | term is |
->| | | | multiplied by |
->| | | | this value if |
->| | | | unsuccessful. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipResTol | OT_REAL | 0.000 | IP residuals |
->| | | | tolerance. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_ipTryRelax | OT_BOOLEAN | True | Enable |
->| | | | relaxation |
->| | | | strategy when |
->| | | | encountering an |
->| | | | error. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_lsItMaxIter | OT_INTEGER | 1000 | Maximum number |
->| | | | of iterations |
->| | | | of the |
->| | | | iterative |
->| | | | linear solvers. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_lsItMethod | OT_STRING | None | Select the |
->| | | | iterative |
->| | | | linear solver. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_lsItPrecondM | OT_STRING | None | Select |
->| ethod | | | preconditioner |
->| | | | for the |
->| | | | iterative |
->| | | | linear solver. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_lsRefineMaxI | OT_INTEGER | 10 | Maximum number |
->| ter | | | of iterative |
->| | | | refinement |
->| | | | steps of the |
->| | | | direct linear |
->| | | | solvers. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_lsScale | OT_BOOLEAN | True | Enables scaling |
->| | | | on linear |
->| | | | solver level. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_lsTol | OT_REAL | 0.000 | Tolerance for |
->| | | | the linear |
->| | | | solver. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_lsTrySimple | OT_BOOLEAN | False | Some matrices |
->| | | | can be solved |
->| | | | without calling |
->| | | | a linear |
->| | | | equation solver |
->| | | | .Currently only |
->| | | | diagonal |
->| | | | matrices are |
->| | | | supported.Non- |
->| | | | diagonal |
->| | | | matrices will |
->| | | | besolved with |
->| | | | the chosen |
->| | | | linear equation |
->| | | | solver. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_maxIter | OT_INTEGER | 80 | Imposes an |
->| | | | upper limit on |
->| | | | the number of |
->| | | | minor solver |
->| | | | iterations, |
->| | | | i.e. for the |
->| | | | quadratic |
->| | | | subproblem |
->| | | | solver.If the |
->| | | | limit is |
->| | | | reached before |
->| | | | convergence, |
->| | | | WORHP will |
->| | | | activate QP |
->| | | | recovery |
->| | | | strategies to |
->| | | | prevent a |
->| | | | solver |
->| | | | breakdown. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_method | OT_STRING | None | Select the |
->| | | | solution method |
->| | | | used by the QP |
->| | | | solver. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_nsnBeta | OT_REAL | 0.900 | NSN stepsize |
->| | | | decrease |
->| | | | factor. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_nsnGradStep | OT_BOOLEAN | True | Enable gradient |
->| | | | steps in the |
->| | | | NSN method. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_nsnKKT | OT_REAL | 0.000 | NSN KKT |
->| | | | tolerance. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_nsnLsMethod | OT_STRING | None | Select the |
->| | | | direct linear |
->| | | | solver used by |
->| | | | the NSN method. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_nsnMinAlpha | OT_REAL | 0.000 | NSN line search |
->| | | | minimum step |
->| | | | size. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_nsnSigma | OT_REAL | 0.010 | NSN line search |
->| | | | slope |
->| | | | parameter. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_printLevel | OT_STRING | None | Controls the |
->| | | | amount of QP |
->| | | | solver output. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_scaleIntern | OT_BOOLEAN | False | Enable scaling |
->| | | | on QP level. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_strict | OT_BOOLEAN | True | Use strict |
->| | | | termination |
->| | | | criteria in IP |
->| | | | method. |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-------------+
->| Id |
->+=============+
->| eval_f |
->+-------------+
->| eval_g |
->+-------------+
->| eval_grad_f |
->+-------------+
->| eval_h |
->+-------------+
->| eval_jac_g |
->+-------------+
->
->>List of available stats
->
->+--------------------+
->| Id |
->+====================+
->| iter_count |
->+--------------------+
->| iteration |
->+--------------------+
->| iterations |
->+--------------------+
->| n_eval_f |
->+--------------------+
->| n_eval_g |
->+--------------------+
->| n_eval_grad_f |
->+--------------------+
->| n_eval_h |
->+--------------------+
->| n_eval_jac_g |
->+--------------------+
->| return_code |
->+--------------------+
->| return_status |
->+--------------------+
->| t_callback_fun |
->+--------------------+
->| t_callback_prepare |
->+--------------------+
->| t_eval_f |
->+--------------------+
->| t_eval_g |
->+--------------------+
->| t_eval_grad_f |
->+--------------------+
->| t_eval_h |
->+--------------------+
->| t_eval_jac_g |
->+--------------------+
->| t_mainloop |
->+--------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->scpgen
->------
->
->
->
->A structure-exploiting sequential quadratic programming (to be come
->sequential convex programming) method for nonlinear programming.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| beta | OT_REAL | 0.800 | Line-search |
->| | | | parameter, |
->| | | | restoration |
->| | | | factor of |
->| | | | stepsize |
->+-----------------+-----------------+-----------------+-----------------+
->| c1 | OT_REAL | 0.000 | Armijo |
->| | | | condition, |
->| | | | coefficient of |
->| | | | decrease in |
->| | | | merit |
->+-----------------+-----------------+-----------------+-----------------+
->| codegen | OT_BOOLEAN | false | C-code |
->| | | | generation |
->+-----------------+-----------------+-----------------+-----------------+
->| compiler | OT_STRING | "gcc -fPIC -O2" | Compiler |
->| | | | command to be |
->| | | | used for |
->| | | | compiling |
->| | | | generated code |
->+-----------------+-----------------+-----------------+-----------------+
->| hessian_approxi | OT_STRING | "exact" | gauss- |
->| mation | | | newton|exact |
->+-----------------+-----------------+-----------------+-----------------+
->| lbfgs_memory | OT_INTEGER | 10 | Size of L-BFGS |
->| | | | memory. |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter | OT_INTEGER | 50 | Maximum number |
->| | | | of SQP |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter_ls | OT_INTEGER | 1 | Maximum number |
->| | | | of linesearch |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| merit_memsize | OT_INTEGER | 4 | Size of memory |
->| | | | to store |
->| | | | history of |
->| | | | merit function |
->| | | | values |
->+-----------------+-----------------+-----------------+-----------------+
->| merit_start | OT_REAL | 0.000 | Lower bound for |
->| | | | the merit |
->| | | | function |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| name_x | OT_STRINGVECTOR | GenericType() | Names of the |
->| | | | variables. |
->+-----------------+-----------------+-----------------+-----------------+
->| print_header | OT_BOOLEAN | true | Print the |
->| | | | header with |
->| | | | problem |
->| | | | statistics |
->+-----------------+-----------------+-----------------+-----------------+
->| print_time | OT_BOOLEAN | true | Print |
->| | | | information |
->| | | | about execution |
->| | | | time |
->+-----------------+-----------------+-----------------+-----------------+
->| print_x | OT_INTEGERVECTO | GenericType() | Which variables |
->| | R | | to print. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_solver | OT_STRING | GenericType() | The QP solver |
->| | | | to be used by |
->| | | | the SQP method |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_solver_optio | OT_DICTIONARY | GenericType() | Options to be |
->| ns | | | passed to the |
->| | | | QP solver |
->+-----------------+-----------------+-----------------+-----------------+
->| reg_threshold | OT_REAL | 0.000 | Threshold for |
->| | | | the |
->| | | | regularization. |
->+-----------------+-----------------+-----------------+-----------------+
->| regularize | OT_BOOLEAN | false | Automatic |
->| | | | regularization |
->| | | | of Lagrange |
->| | | | Hessian. |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_du | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | dual |
->| | | | infeasability |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_pr | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | primal |
->| | | | infeasibility |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_pr_step | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | the step size |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_reg | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | regularization |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-------------+
->| Id |
->+=============+
->| dx |
->+-------------+
->| eval_f |
->+-------------+
->| eval_g |
->+-------------+
->| eval_grad_f |
->+-------------+
->| eval_h |
->+-------------+
->| eval_jac_g |
->+-------------+
->| qp |
->+-------------+
->
->>List of available stats
->
->+------------+
->| Id |
->+============+
->| iter_count |
->+------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->sqpmethod
->---------
->
->
->
->A textbook SQPMethod
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| beta | OT_REAL | 0.800 | Line-search |
->| | | | parameter, |
->| | | | restoration |
->| | | | factor of |
->| | | | stepsize |
->+-----------------+-----------------+-----------------+-----------------+
->| c1 | OT_REAL | 0.000 | Armijo |
->| | | | condition, |
->| | | | coefficient of |
->| | | | decrease in |
->| | | | merit |
->+-----------------+-----------------+-----------------+-----------------+
->| hessian_approxi | OT_STRING | "exact" | limited- |
->| mation | | | memory|exact |
->+-----------------+-----------------+-----------------+-----------------+
->| lbfgs_memory | OT_INTEGER | 10 | Size of L-BFGS |
->| | | | memory. |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter | OT_INTEGER | 50 | Maximum number |
->| | | | of SQP |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter_ls | OT_INTEGER | 3 | Maximum number |
->| | | | of linesearch |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| merit_memory | OT_INTEGER | 4 | Size of memory |
->| | | | to store |
->| | | | history of |
->| | | | merit function |
->| | | | values |
->+-----------------+-----------------+-----------------+-----------------+
->| min_step_size | OT_REAL | 0.000 | The size (inf- |
->| | | | norm) of the |
->| | | | step size |
->| | | | should not |
->| | | | become smaller |
->| | | | than this. |
->+-----------------+-----------------+-----------------+-----------------+
->| print_header | OT_BOOLEAN | true | Print the |
->| | | | header with |
->| | | | problem |
->| | | | statistics |
->+-----------------+-----------------+-----------------+-----------------+
->| print_time | OT_BOOLEAN | true | Print |
->| | | | information |
->| | | | about execution |
->| | | | time |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_solver | OT_STRING | GenericType() | The QP solver |
->| | | | to be used by |
->| | | | the SQP method |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_solver_optio | OT_DICTIONARY | GenericType() | Options to be |
->| ns | | | passed to the |
->| | | | QP solver |
->+-----------------+-----------------+-----------------+-----------------+
->| regularize | OT_BOOLEAN | false | Automatic |
->| | | | regularization |
->| | | | of Lagrange |
->| | | | Hessian. |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_du | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | dual |
->| | | | infeasability |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_pr | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | primal |
->| | | | infeasibility |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-------------+
->| Id |
->+=============+
->| bfgs |
->+-------------+
->| dx |
->+-------------+
->| eval_f |
->+-------------+
->| eval_g |
->+-------------+
->| eval_grad_f |
->+-------------+
->| eval_h |
->+-------------+
->| eval_jac_g |
->+-------------+
->| qp |
->+-------------+
->
->>List of available stats
->
->+--------------------+
->| Id |
->+====================+
->| iter_count |
->+--------------------+
->| iteration |
->+--------------------+
->| iterations |
->+--------------------+
->| n_eval_f |
->+--------------------+
->| n_eval_g |
->+--------------------+
->| n_eval_grad_f |
->+--------------------+
->| n_eval_h |
->+--------------------+
->| n_eval_jac_g |
->+--------------------+
->| return_status |
->+--------------------+
->| t_callback_fun |
->+--------------------+
->| t_callback_prepare |
->+--------------------+
->| t_eval_f |
->+--------------------+
->| t_eval_g |
->+--------------------+
->| t_eval_grad_f |
->+--------------------+
->| t_eval_h |
->+--------------------+
->| t_eval_jac_g |
->+--------------------+
->| t_mainloop |
->+--------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->stabilizedsqp
->-------------
->
->
->
->Stabilized Sequential Quadratic Programming method.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| TReta1 | OT_REAL | 0.800 | Required |
->| | | | predicted / |
->| | | | actual decrease |
->| | | | for TR increase |
->+-----------------+-----------------+-----------------+-----------------+
->| TReta2 | OT_REAL | 0.200 | Required |
->| | | | predicted / |
->| | | | actual decrease |
->| | | | for TR decrease |
->+-----------------+-----------------+-----------------+-----------------+
->| alphaMin | OT_REAL | 0.001 | Used to check |
->| | | | whether to |
->| | | | increase rho. |
->+-----------------+-----------------+-----------------+-----------------+
->| beta | OT_REAL | 0.500 | Line-search |
->| | | | parameter, |
->| | | | restoration |
->| | | | factor of |
->| | | | stepsize |
->+-----------------+-----------------+-----------------+-----------------+
->| c1 | OT_REAL | 0.001 | Armijo |
->| | | | condition, |
->| | | | coefficient of |
->| | | | decrease in |
->| | | | merit |
->+-----------------+-----------------+-----------------+-----------------+
->| dvMax0 | OT_REAL | 100 | Parameter used |
->| | | | to defined the |
->| | | | max step |
->| | | | length. |
->+-----------------+-----------------+-----------------+-----------------+
->| eps_active | OT_REAL | 0.000 | Threshold for |
->| | | | the epsilon- |
->| | | | active set. |
->+-----------------+-----------------+-----------------+-----------------+
->| gamma1 | OT_REAL | 2 | Trust region |
->| | | | increase |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| gamma2 | OT_REAL | 1 | Trust region |
->| | | | update |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| gamma3 | OT_REAL | 1 | Trust region |
->| | | | decrease |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| hessian_approxi | OT_STRING | "exact" | limited- |
->| mation | | | memory|exact |
->+-----------------+-----------------+-----------------+-----------------+
->| lbfgs_memory | OT_INTEGER | 10 | Size of L-BFGS |
->| | | | memory. |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter | OT_INTEGER | 100 | Maximum number |
->| | | | of SQP |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| max_iter_ls | OT_INTEGER | 20 | Maximum number |
->| | | | of linesearch |
->| | | | iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| max_time | OT_REAL | 1.000e+12 | Timeout |
->+-----------------+-----------------+-----------------+-----------------+
->| merit_memory | OT_INTEGER | 4 | Size of memory |
->| | | | to store |
->| | | | history of |
->| | | | merit function |
->| | | | values |
->+-----------------+-----------------+-----------------+-----------------+
->| min_step_size | OT_REAL | 0.000 | The size (inf- |
->| | | | norm) of the |
->| | | | step size |
->| | | | should not |
->| | | | become smaller |
->| | | | than this. |
->+-----------------+-----------------+-----------------+-----------------+
->| muR0 | OT_REAL | 0.000 | Initial choice |
->| | | | of |
->| | | | regularization |
->| | | | parameter |
->+-----------------+-----------------+-----------------+-----------------+
->| nu | OT_REAL | 1 | Parameter for |
->| | | | primal-dual |
->| | | | augmented |
->| | | | Lagrangian. |
->+-----------------+-----------------+-----------------+-----------------+
->| phiWeight | OT_REAL | 0.000 | Weight used in |
->| | | | pseudo-filter. |
->+-----------------+-----------------+-----------------+-----------------+
->| print_header | OT_BOOLEAN | true | Print the |
->| | | | header with |
->| | | | problem |
->| | | | statistics |
->+-----------------+-----------------+-----------------+-----------------+
->| regularize | OT_BOOLEAN | false | Automatic |
->| | | | regularization |
->| | | | of Lagrange |
->| | | | Hessian. |
->+-----------------+-----------------+-----------------+-----------------+
->| stabilized_qp_s | OT_STRING | GenericType() | The Stabilized |
->| olver | | | QP solver to be |
->| | | | used by the SQP |
->| | | | method |
->+-----------------+-----------------+-----------------+-----------------+
->| stabilized_qp_s | OT_DICTIONARY | GenericType() | Options to be |
->| olver_options | | | passed to the |
->| | | | Stabilized QP |
->| | | | solver |
->+-----------------+-----------------+-----------------+-----------------+
->| tau0 | OT_REAL | 0.010 | Initial |
->| | | | parameter for |
->| | | | the merit |
->| | | | function |
->| | | | optimality |
->| | | | threshold. |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_du | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | dual |
->| | | | infeasability |
->+-----------------+-----------------+-----------------+-----------------+
->| tol_pr | OT_REAL | 0.000 | Stopping |
->| | | | criterion for |
->| | | | primal |
->| | | | infeasibility |
->+-----------------+-----------------+-----------------+-----------------+
->| yEinitial | OT_STRING | "simple" | Initial |
->| | | | multiplier. |
->| | | | Simple (all |
->| | | | zero) or least |
->| | | | (LSQ). |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available monitors
->
->+-------------+
->| Id |
->+=============+
->| dx |
->+-------------+
->| eval_f |
->+-------------+
->| eval_g |
->+-------------+
->| eval_grad_f |
->+-------------+
->| eval_h |
->+-------------+
->| eval_jac_g |
->+-------------+
->| qp |
->+-------------+
->
->>List of available stats
->
->+---------------+
->| Id |
->+===============+
->| iter_count |
->+---------------+
->| return_status |
->+---------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: nlp_solver.hpp
--}
-newtype NlpSolver = NlpSolver (ForeignPtr NlpSolver')
--- typeclass decl
-class NlpSolverClass a where
- castNlpSolver :: a -> NlpSolver
-instance NlpSolverClass NlpSolver where
- castNlpSolver = id
-
--- baseclass instances
-instance FunctionClass NlpSolver where
- castFunction (NlpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass NlpSolver where
- castOptionsFunctionality (NlpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass NlpSolver where
- castPrintableObject (NlpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass NlpSolver where
- castSharedObject (NlpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass NlpSolver where
- castIOInterfaceFunction (NlpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal NlpSolver (Ptr NlpSolver') where
- marshal (NlpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (NlpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__NlpSolver"
- c_delete_casadi__NlpSolver :: FunPtr (Ptr NlpSolver' -> IO ())
-instance WrapReturn (Ptr NlpSolver') NlpSolver where
- wrapReturn = (fmap NlpSolver) . (newForeignPtr c_delete_casadi__NlpSolver)
-
-
--- raw decl
-data Nullspace'
--- data decl
-{-|
->Base class for nullspace construction.
->
->Constructs a basis for the null-space of a fat matrix A. i.e. finds Z such
->that AZ = 0 holds.
->
->The nullspace is also known as the orthogonal complement of the rowspace of
->a matrix.
->
->It is assumed that the matrix A is of full rank.
->
->Implementations are not required to construct an orthogonal or orthonormal
->basis Joris Gillis
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| dense | OT_BOOLEAN | true | Indicates | casadi::Null |
->| | | | that dense | spaceInterna |
->| | | | matrices can | l |
->| | | | be assumed | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: nullspace.hpp
--}
-newtype Nullspace = Nullspace (ForeignPtr Nullspace')
--- typeclass decl
-class NullspaceClass a where
- castNullspace :: a -> Nullspace
-instance NullspaceClass Nullspace where
- castNullspace = id
-
--- baseclass instances
-instance FunctionClass Nullspace where
- castFunction (Nullspace x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Nullspace where
- castOptionsFunctionality (Nullspace x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass Nullspace where
- castPrintableObject (Nullspace x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass Nullspace where
- castSharedObject (Nullspace x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Nullspace where
- castIOInterfaceFunction (Nullspace x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Nullspace (Ptr Nullspace') where
- marshal (Nullspace x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Nullspace x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Nullspace"
- c_delete_casadi__Nullspace :: FunPtr (Ptr Nullspace' -> IO ())
-instance WrapReturn (Ptr Nullspace') Nullspace where
- wrapReturn = (fmap Nullspace) . (newForeignPtr c_delete_casadi__Nullspace)
-
-
--- raw decl
-data OCPSolver'
--- data decl
-{-|
->Base class for OCP solvers.
->
->Joel Andersson
->
->>Input scheme: casadi::OCPInput (OCP_NUM_IN = 13) [ocpIn]
->
->+------------+--------+----------------------------------------------+
->| Full name | Short | Description |
->+============+========+==============================================+
->| OCP_LBX | lbx | States lower bounds (nx x (ns+1)) . |
->+------------+--------+----------------------------------------------+
->| OCP_UBX | ubx | States upper bounds (nx x (ns+1)) . |
->+------------+--------+----------------------------------------------+
->| OCP_X_INIT | x_init | States initial guess (nx x (ns+1)) . |
->+------------+--------+----------------------------------------------+
->| OCP_LBU | lbu | Controls lower bounds (nu x ns) . |
->+------------+--------+----------------------------------------------+
->| OCP_UBU | ubu | Controls upper bounds (nu x ns) . |
->+------------+--------+----------------------------------------------+
->| OCP_U_INIT | u_init | Controls initial guess (nu x ns) . |
->+------------+--------+----------------------------------------------+
->| OCP_LBP | lbp | Parameters lower bounds (np x 1) . |
->+------------+--------+----------------------------------------------+
->| OCP_UBP | ubp | Parameters upper bounds (np x 1) . |
->+------------+--------+----------------------------------------------+
->| OCP_P_INIT | p_init | Parameters initial guess (np x 1) . |
->+------------+--------+----------------------------------------------+
->| OCP_LBH | lbh | Point constraint lower bound (nh x (ns+1)) . |
->+------------+--------+----------------------------------------------+
->| OCP_UBH | ubh | Point constraint upper bound (nh x (ns+1)) . |
->+------------+--------+----------------------------------------------+
->| OCP_LBG | lbg | Lower bound for the coupling constraints . |
->+------------+--------+----------------------------------------------+
->| OCP_UBG | ubg | Upper bound for the coupling constraints . |
->+------------+--------+----------------------------------------------+
->
->>Output scheme: casadi::OCPOutput (OCP_NUM_OUT = 4) [ocpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| OCP_X_OPT | x_opt | Optimal state |
->| | | trajectory . |
->+------------------------+------------------------+------------------------+
->| OCP_U_OPT | u_opt | Optimal control |
->| | | trajectory . |
->+------------------------+------------------------+------------------------+
->| OCP_P_OPT | p_opt | Optimal parameters . |
->+------------------------+------------------------+------------------------+
->| OCP_COST | cost | Objective/cost |
->| | | function for optimal |
->| | | solution (1 x 1) . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| final_time | OT_REAL | 1 | | casadi::OCPS |
->| | | | | olverInterna |
->| | | | | l |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| number_of_gr | OT_INTEGER | 20 | | casadi::OCPS |
->| id_points | | | | olverInterna |
->| | | | | l |
->+--------------+--------------+--------------+--------------+--------------+
->| number_of_pa | OT_INTEGER | 0 | | casadi::OCPS |
->| rameters | | | | olverInterna |
->| | | | | l |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: ocp_solver.hpp
--}
-newtype OCPSolver = OCPSolver (ForeignPtr OCPSolver')
--- typeclass decl
-class OCPSolverClass a where
- castOCPSolver :: a -> OCPSolver
-instance OCPSolverClass OCPSolver where
- castOCPSolver = id
-
--- baseclass instances
-instance FunctionClass OCPSolver where
- castFunction (OCPSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass OCPSolver where
- castOptionsFunctionality (OCPSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass OCPSolver where
- castPrintableObject (OCPSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass OCPSolver where
- castSharedObject (OCPSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass OCPSolver where
- castIOInterfaceFunction (OCPSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal OCPSolver (Ptr OCPSolver') where
- marshal (OCPSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (OCPSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__OCPSolver"
- c_delete_casadi__OCPSolver :: FunPtr (Ptr OCPSolver' -> IO ())
-instance WrapReturn (Ptr OCPSolver') OCPSolver where
- wrapReturn = (fmap OCPSolver) . (newForeignPtr c_delete_casadi__OCPSolver)
-
-
--- raw decl
-data OptionsFunctionality'
--- data decl
-{-|
->Provides options setting/getting functionality.
->
->Gives a derived class the ability to set and retrieve options in a
->convenient way. It also contains error checking, making sure that the option
->exists and that the value type is correct.
->
->A derived class should add option names, types and default values to the
->corresponding vectors.
->
->Joel Andersson
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: options_functionality.hpp
--}
-newtype OptionsFunctionality = OptionsFunctionality (ForeignPtr OptionsFunctionality')
--- typeclass decl
-class OptionsFunctionalityClass a where
- castOptionsFunctionality :: a -> OptionsFunctionality
-instance OptionsFunctionalityClass OptionsFunctionality where
- castOptionsFunctionality = id
-
--- baseclass instances
-instance PrintableObjectClass OptionsFunctionality where
- castPrintableObject (OptionsFunctionality x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass OptionsFunctionality where
- castSharedObject (OptionsFunctionality x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal OptionsFunctionality (Ptr OptionsFunctionality') where
- marshal (OptionsFunctionality x) = return (unsafeForeignPtrToPtr x)
- marshalFree (OptionsFunctionality x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__OptionsFunctionality"
- c_delete_casadi__OptionsFunctionality :: FunPtr (Ptr OptionsFunctionality' -> IO ())
-instance WrapReturn (Ptr OptionsFunctionality') OptionsFunctionality where
- wrapReturn = (fmap OptionsFunctionality) . (newForeignPtr c_delete_casadi__OptionsFunctionality)
-
-
--- raw decl
-data Parallelizer'
--- data decl
-{-|
->Parallelizer execution of functions.
->
->Joel Andersson
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| parallelizat | OT_STRING | "serial" | (serial|open | casadi::Para |
->| ion | | | mp|mpi) | llelizerInte |
->| | | | | rnal |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->>List of available stats
->
->+-----------------+------------------------------+
->| Id | Used in |
->+=================+==============================+
->| max_threads | casadi::ParallelizerInternal |
->+-----------------+------------------------------+
->| num_threads | casadi::ParallelizerInternal |
->+-----------------+------------------------------+
->| task_allocation | casadi::ParallelizerInternal |
->+-----------------+------------------------------+
->| task_cputime | casadi::ParallelizerInternal |
->+-----------------+------------------------------+
->| task_endtime | casadi::ParallelizerInternal |
->+-----------------+------------------------------+
->| task_order | casadi::ParallelizerInternal |
->+-----------------+------------------------------+
->| task_starttime | casadi::ParallelizerInternal |
->+-----------------+------------------------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: parallelizer.hpp
--}
-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 PrintableObjectClass Parallelizer where
- castPrintableObject (Parallelizer x) = PrintableObject (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 PrintableObject'
--- data decl
-{-|
->Base class for objects that have a natural string representation.
->
->Joel Andersson
->
->C++ includes: printable_object.hpp
--}
-newtype PrintableObject = PrintableObject (ForeignPtr PrintableObject')
--- typeclass decl
-class PrintableObjectClass a where
- castPrintableObject :: a -> PrintableObject
-instance PrintableObjectClass PrintableObject where
- castPrintableObject = id
-
--- baseclass instances
-
--- helper instances
-instance Marshal PrintableObject (Ptr PrintableObject') where
- marshal (PrintableObject x) = return (unsafeForeignPtrToPtr x)
- marshalFree (PrintableObject x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__PrintableObject"
- c_delete_casadi__PrintableObject :: FunPtr (Ptr PrintableObject' -> IO ())
-instance WrapReturn (Ptr PrintableObject') PrintableObject where
- wrapReturn = (fmap PrintableObject) . (newForeignPtr c_delete_casadi__PrintableObject)
-
-
--- raw decl
-data QcqpSolver'
--- data decl
-{-|
->QcqpSolver.
->
->Solves the following strictly convex problem:
->
->
->
->::
->
-> min 1/2 x' H x + g' x
-> x
->
-> subject to
-> 1/2 x' Pi x + qi' x + ri <= 0 for i=0..nq-1
-> LBA <= A x <= UBA
-> LBX <= x <= UBX
->
-> with :
-> H, Pi sparse (n x n) positive definite
-> g, qi dense (n x 1)
-> ri scalar
->
-> n: number of decision variables (x)
-> nc: number of linear constraints (A)
-> nq: number of quadratic constraints
->
->
->
->If H, Pi is not positive-definite, the solver should throw an error.
->
->General information
->===================
->
->
->
->>Input scheme: casadi::QcqpSolverInput (QCQP_SOLVER_NUM_IN = 12) [qcqpIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| QCQP_SOLVER_H | h | The square matrix H: |
->| | | sparse, (n x n). Only |
->| | | the lower triangular |
->| | | part is actually used. |
->| | | The matrix is assumed |
->| | | to be symmetrical. |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_G | g | The vector g: dense, |
->| | | (n x 1) . |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_P | p | The horizontal stack |
->| | | of all Pi. Each Pi is |
->| | | sparse (n x n). Only |
->| | | the lower triangular |
->| | | part is actually used. |
->| | | The matrix is assumed |
->| | | to be symmetrical. |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_Q | q | The vertical stack of |
->| | | all qi: dense, (nq n x |
->| | | 1) . |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_R | r | The vertical stack of |
->| | | all scalars ri (nq x |
->| | | 1) . |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_A | a | The matrix A: sparse, |
->| | | (nc x n) - product |
->| | | with x must be dense. |
->| | | . |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_LBA | lba | dense, (nc x 1) |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_UBA | uba | dense, (nc x 1) |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_LBX | lbx | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_UBX | ubx | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_X0 | x0 | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_LAM_X0 | lam_x0 | dense |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::QcqpSolverOutput (QCQP_SOLVER_NUM_OUT = 4) [qcqpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| QCQP_SOLVER_X | x | The primal solution . |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_COST | cost | The optimal cost . |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_LAM_A | lam_a | The dual solution |
->| | | corresponding to |
->| | | linear bounds . |
->+------------------------+------------------------+------------------------+
->| QCQP_SOLVER_LAM_X | lam_x | The dual solution |
->| | | corresponding to |
->| | | simple bounds . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- socp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->QcqpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->socp
->----
->
->
->
->Solve a QCQP with an SocpSolver
->
->Note: this implementation relies on Cholesky decomposition: Chol(H) = L -> H
->= LL' with L lower triangular This requires Pi, H to be positive definite.
->Positive semi-definite is not sufficient. Notably, H==0 will not work.
->
->A better implementation would rely on matrix square root, but we need
->singular value decomposition to implement that.
->
->This implementation makes use of the epigraph reformulation:
->
->::
->
-> * min f(x)
-> * x
-> *
-> * min t
-> * x, t f(x) <= t
-> *
->
->
->
->This implementation makes use of the following identity:
->
->::
->
-> * || Gx+h||_2 <= e'x + f
-> *
-> * x'(G'G - ee')x + (2 h'G - 2 f e') x + h'h - f <= 0
-> *
->
->where we put e = [0 0 ... 1] for the quadratic constraint arising from the
->epigraph reformulation and e==0 for all other quadratic constraints.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| socp_solver | OT_STRING | GenericType() | The SocpSolver |
->| | | | used to solve |
->| | | | the QCQPs. |
->+-----------------+-----------------+-----------------+-----------------+
->| socp_solver_opt | OT_DICTIONARY | GenericType() | Options to be |
->| ions | | | passed to the |
->| | | | SOCPSOlver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+-------------------+
->| Id |
->+===================+
->| socp_solver_stats |
->+-------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joris Gillis
->Diagrams
->--------
->
->
->
->C++ includes: qcqp_solver.hpp
--}
-newtype QcqpSolver = QcqpSolver (ForeignPtr QcqpSolver')
--- typeclass decl
-class QcqpSolverClass a where
- castQcqpSolver :: a -> QcqpSolver
-instance QcqpSolverClass QcqpSolver where
- castQcqpSolver = id
-
--- baseclass instances
-instance FunctionClass QcqpSolver where
- castFunction (QcqpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass QcqpSolver where
- castOptionsFunctionality (QcqpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass QcqpSolver where
- castPrintableObject (QcqpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass QcqpSolver where
- castSharedObject (QcqpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass QcqpSolver where
- castIOInterfaceFunction (QcqpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal QcqpSolver (Ptr QcqpSolver') where
- marshal (QcqpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (QcqpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__QcqpSolver"
- c_delete_casadi__QcqpSolver :: FunPtr (Ptr QcqpSolver' -> IO ())
-instance WrapReturn (Ptr QcqpSolver') QcqpSolver where
- wrapReturn = (fmap QcqpSolver) . (newForeignPtr c_delete_casadi__QcqpSolver)
-
-
--- raw decl
-data QpSolver'
--- data decl
-{-|
->QpSolver.
->
->Solves the following strictly convex problem:
->
->
->
->::
->
-> min 1/2 x' H x + g' x
-> x
->
-> subject to
-> LBA <= A x <= UBA
-> LBX <= x <= UBX
->
-> with :
-> H sparse (n x n) positive definite
-> g dense (n x 1)
->
-> n: number of decision variables (x)
-> nc: number of constraints (A)
->
->
->
->If H is not positive-definite, the solver should throw an error.
->
->General information
->===================
->
->
->
->>Input scheme: casadi::QpSolverInput (QP_SOLVER_NUM_IN = 9) [qpIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| QP_SOLVER_H | h | The square matrix H: |
->| | | sparse, (n x n). Only |
->| | | the lower triangular |
->| | | part is actually used. |
->| | | The matrix is assumed |
->| | | to be symmetrical. |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_G | g | The vector g: dense, |
->| | | (n x 1) . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_A | a | The matrix A: sparse, |
->| | | (nc x n) - product |
->| | | with x must be dense. |
->| | | . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_LBA | lba | dense, (nc x 1) |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_UBA | uba | dense, (nc x 1) |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_LBX | lbx | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_UBX | ubx | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_X0 | x0 | dense, (n x 1) |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_LAM_X0 | lam_x0 | dense |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::QpSolverOutput (QP_SOLVER_NUM_OUT = 4) [qpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| QP_SOLVER_X | x | The primal solution . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_COST | cost | The optimal cost . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_LAM_A | lam_a | The dual solution |
->| | | corresponding to |
->| | | linear bounds . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_LAM_X | lam_x | The dual solution |
->| | | corresponding to |
->| | | simple bounds . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- cplex
->
->- ooqp
->
->- qpoases
->
->- sqic
->
->- nlp
->
->- qcqp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->QpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->cplex
->-----
->
->
->
->Interface to Cplex solver for sparse Quadratic Programs
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| barrier_maxiter | OT_INTEGER | 2.100e+09 | Maximum number |
->| | | | of barrier |
->| | | | iterations. |
->+-----------------+-----------------+-----------------+-----------------+
->| convex | OT_BOOLEAN | true | Indicates if |
->| | | | the QP is |
->| | | | convex or not |
->| | | | (affects only |
->| | | | the barrier |
->| | | | method). |
->+-----------------+-----------------+-----------------+-----------------+
->| dep_check | OT_STRING | "off" | Detect |
->| | | | redundant |
->| | | | constraints. (a |
->| | | | utomatic:-1|off |
->| | | | :0|begin:1|end: |
->| | | | 2|both:3) |
->+-----------------+-----------------+-----------------+-----------------+
->| dump_filename | OT_STRING | "qp.dat" | The filename to |
->| | | | dump to. |
->+-----------------+-----------------+-----------------+-----------------+
->| dump_to_file | OT_BOOLEAN | false | Dumps QP to |
->| | | | file in CPLEX |
->| | | | format. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_method | OT_STRING | "automatic" | Determines |
->| | | | which CPLEX |
->| | | | algorithm to |
->| | | | use. (automatic |
->| | | | |primal_simplex |
->| | | | |dual_simplex|n |
->| | | | etwork|barrier| |
->| | | | sifting|concurr |
->| | | | ent|crossover) |
->+-----------------+-----------------+-----------------+-----------------+
->| simplex_maxiter | OT_INTEGER | 2.100e+09 | Maximum number |
->| | | | of simplex |
->| | | | iterations. |
->+-----------------+-----------------+-----------------+-----------------+
->| tol | OT_REAL | 0.000 | Tolerance of |
->| | | | solver |
->+-----------------+-----------------+-----------------+-----------------+
->| warm_start | OT_BOOLEAN | false | Use warm start |
->| | | | with simplex |
->| | | | methods |
->| | | | (affects only |
->| | | | the simplex |
->| | | | methods). |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->ooqp
->----
->
->
->
->Interface to the OOQP Solver for quadratic programming The current
->implementation assumes that OOQP is configured with the MA27 sparse linear
->solver.
->
->NOTE: when doing multiple calls to evaluate(), check if you need to
->reInit();
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| artol | OT_REAL | 0.000 | tolerance as |
->| | | | provided with |
->| | | | setArTol to |
->| | | | OOQP |
->+-----------------+-----------------+-----------------+-----------------+
->| mutol | OT_REAL | 0.000 | tolerance as |
->| | | | provided with |
->| | | | setMuTol to |
->| | | | OOQP |
->+-----------------+-----------------+-----------------+-----------------+
->| print_level | OT_INTEGER | 0 | Print level. |
->| | | | OOQP listens to |
->| | | | print_level 0, |
->| | | | 10 and 100 |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->qpoases
->-------
->
->
->
->Interface to QPOases Solver for quadratic programming
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| CPUtime | OT_REAL | None | The maximum |
->| | | | allowed CPU |
->| | | | time in seconds |
->| | | | for the whole |
->| | | | initialisation |
->| | | | (and the |
->| | | | actually |
->| | | | required one on |
->| | | | output). |
->| | | | Disabled if |
->| | | | unset. |
->+-----------------+-----------------+-----------------+-----------------+
->| boundRelaxation | OT_REAL | 10000 | Initial |
->| | | | relaxation of |
->| | | | bounds to start |
->| | | | homotopy and |
->| | | | initial value |
->| | | | for far bounds. |
->+-----------------+-----------------+-----------------+-----------------+
->| boundTolerance | OT_REAL | 0.000 | If upper and |
->| | | | lower bounds |
->| | | | differ less |
->| | | | than this |
->| | | | tolerance, they |
->| | | | are regarded |
->| | | | equal, i.e. as |
->| | | | equality |
->| | | | constraint. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableCholeskyR | OT_INTEGER | 0 | Specifies the |
->| efactorisation | | | frequency of a |
->| | | | full re- |
->| | | | factorisation |
->| | | | of projected |
->| | | | Hessian matrix: |
->| | | | 0: turns them |
->| | | | off, 1: uses |
->| | | | them at each |
->| | | | iteration etc. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableDriftCorr | OT_INTEGER | 1 | Specifies the |
->| ection | | | frequency of |
->| | | | drift |
->| | | | corrections: 0: |
->| | | | turns them off. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableEqualitie | OT_BOOLEAN | False | Specifies |
->| s | | | whether |
->| | | | equalities |
->| | | | should be |
->| | | | treated as |
->| | | | always active |
->| | | | (True) or not |
->| | | | (False) |
->+-----------------+-----------------+-----------------+-----------------+
->| enableFarBounds | OT_BOOLEAN | True | Enables the use |
->| | | | of far bounds. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableFlippingB | OT_BOOLEAN | True | Enables the use |
->| ounds | | | of flipping |
->| | | | bounds. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableFullLITes | OT_BOOLEAN | False | Enables |
->| ts | | | condition- |
->| | | | hardened (but |
->| | | | more expensive) |
->| | | | LI test. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableNZCTests | OT_BOOLEAN | True | Enables nonzero |
->| | | | curvature |
->| | | | tests. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableRamping | OT_BOOLEAN | True | Enables |
->| | | | ramping. |
->+-----------------+-----------------+-----------------+-----------------+
->| enableRegularis | OT_BOOLEAN | False | Enables |
->| ation | | | automatic |
->| | | | Hessian |
->| | | | regularisation. |
->+-----------------+-----------------+-----------------+-----------------+
->| epsDen | OT_REAL | 0.000 | Denominator |
->| | | | tolerance for |
->| | | | ratio tests. |
->+-----------------+-----------------+-----------------+-----------------+
->| epsFlipping | OT_REAL | 0.000 | Tolerance of |
->| | | | squared |
->| | | | Cholesky |
->| | | | diagonal factor |
->| | | | which triggers |
->| | | | flipping bound. |
->+-----------------+-----------------+-----------------+-----------------+
->| epsIterRef | OT_REAL | 0.000 | Early |
->| | | | termination |
->| | | | tolerance for |
->| | | | iterative |
->| | | | refinement. |
->+-----------------+-----------------+-----------------+-----------------+
->| epsLITests | OT_REAL | 0.000 | Tolerance for |
->| | | | linear |
->| | | | independence |
->| | | | tests. |
->+-----------------+-----------------+-----------------+-----------------+
->| epsNZCTests | OT_REAL | 0.000 | Tolerance for |
->| | | | nonzero |
->| | | | curvature |
->| | | | tests. |
->+-----------------+-----------------+-----------------+-----------------+
->| epsNum | OT_REAL | -0.000 | Numerator |
->| | | | tolerance for |
->| | | | ratio tests. |
->+-----------------+-----------------+-----------------+-----------------+
->| epsRegularisati | OT_REAL | 0.000 | Scaling factor |
->| on | | | of identity |
->| | | | matrix used for |
->| | | | Hessian |
->| | | | regularisation. |
->+-----------------+-----------------+-----------------+-----------------+
->| finalRamping | OT_REAL | 1 | Final value for |
->| | | | ramping |
->| | | | strategy. |
->+-----------------+-----------------+-----------------+-----------------+
->| growFarBounds | OT_REAL | 1000 | Factor to grow |
->| | | | far bounds. |
->+-----------------+-----------------+-----------------+-----------------+
->| initialFarBound | OT_REAL | 1000000 | Initial size |
->| s | | | for far bounds. |
->+-----------------+-----------------+-----------------+-----------------+
->| initialRamping | OT_REAL | 0.500 | Start value for |
->| | | | ramping |
->| | | | strategy. |
->+-----------------+-----------------+-----------------+-----------------+
->| initialStatusBo | OT_STRING | lower | Initial status |
->| unds | | | of bounds at |
->| | | | first |
->| | | | iteration. |
->+-----------------+-----------------+-----------------+-----------------+
->| maxDualJump | OT_REAL | 100000000 | Maximum allowed |
->| | | | jump in dual |
->| | | | variables in |
->| | | | linear |
->| | | | independence |
->| | | | tests. |
->+-----------------+-----------------+-----------------+-----------------+
->| maxPrimalJump | OT_REAL | 100000000 | Maximum allowed |
->| | | | jump in primal |
->| | | | variables in |
->| | | | nonzero |
->| | | | curvature |
->| | | | tests. |
->+-----------------+-----------------+-----------------+-----------------+
->| nWSR | OT_INTEGER | None | The maximum |
->| | | | number of |
->| | | | working set |
->| | | | recalculations |
->| | | | to be performed |
->| | | | during the |
->| | | | initial |
->| | | | homotopy. |
->| | | | Default is 5(nx |
->| | | | + nc) |
->+-----------------+-----------------+-----------------+-----------------+
->| numRefinementSt | OT_INTEGER | 1 | Maximum number |
->| eps | | | of iterative |
->| | | | refinement |
->| | | | steps. |
->+-----------------+-----------------+-----------------+-----------------+
->| numRegularisati | OT_INTEGER | 0 | Maximum number |
->| onSteps | | | of successive |
->| | | | regularisation |
->| | | | steps. |
->+-----------------+-----------------+-----------------+-----------------+
->| printLevel | OT_STRING | medium | Defines the |
->| | | | amount of text |
->| | | | output during |
->| | | | QP solution, |
->| | | | see Section 5.7 |
->+-----------------+-----------------+-----------------+-----------------+
->| terminationTole | OT_REAL | 0.000 | Relative |
->| rance | | | termination |
->| | | | tolerance to |
->| | | | stop homotopy. |
->+-----------------+-----------------+-----------------+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->sqic
->----
->
->
->
->Interface to the SQIC solver for quadratic programming
->
->>List of available options
->
->+----+------+---------+-------------+
->| Id | Type | Default | Description |
->+====+======+=========+=============+
->+----+------+---------+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->nlp
->---
->
->
->
->Solve QPs using an NlpSolver
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| nlp_solver | OT_STRING | GenericType() | The NLPSOlver |
->| | | | used to solve |
->| | | | the QPs. |
->+-----------------+-----------------+-----------------+-----------------+
->| nlp_solver_opti | OT_DICTIONARY | GenericType() | Options to be |
->| ons | | | passed to the |
->| | | | NLPSOlver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+------------------+
->| Id |
->+==================+
->| nlp_solver_stats |
->+------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->qcqp
->----
->
->
->
->Solve QP using a QcqpSolver
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| qcqp_solver | OT_STRING | GenericType() | The QcqpSolver |
->| | | | used to solve |
->| | | | the QPs. |
->+-----------------+-----------------+-----------------+-----------------+
->| qcqp_solver_opt | OT_DICTIONARY | GenericType() | Options to be |
->| ions | | | passed to the |
->| | | | QCQPSOlver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+-------------------+
->| Id |
->+===================+
->| qcqp_solver_stats |
->+-------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: qp_solver.hpp
--}
-newtype QpSolver = QpSolver (ForeignPtr QpSolver')
--- typeclass decl
-class QpSolverClass a where
- castQpSolver :: a -> QpSolver
-instance QpSolverClass QpSolver where
- castQpSolver = id
-
--- baseclass instances
-instance FunctionClass QpSolver where
- castFunction (QpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass QpSolver where
- castOptionsFunctionality (QpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass QpSolver where
- castPrintableObject (QpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass QpSolver where
- castSharedObject (QpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass QpSolver where
- castIOInterfaceFunction (QpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal QpSolver (Ptr QpSolver') where
- marshal (QpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (QpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__QpSolver"
- c_delete_casadi__QpSolver :: FunPtr (Ptr QpSolver' -> IO ())
-instance WrapReturn (Ptr QpSolver') QpSolver where
- wrapReturn = (fmap QpSolver) . (newForeignPtr c_delete_casadi__QpSolver)
-
-
--- raw decl
-data SX'
--- data decl
-{-|
--}
-newtype SX = SX (ForeignPtr SX')
--- typeclass decl
-class SXClass a where
- castSX :: a -> SX
-instance SXClass SX where
- castSX = id
-
--- baseclass instances
-instance PrintableObjectClass SX where
- castPrintableObject (SX x) = PrintableObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SX (Ptr SX') where
- marshal (SX x) = return (unsafeForeignPtrToPtr x)
- marshalFree (SX x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SX"
- c_delete_casadi__SX :: FunPtr (Ptr SX' -> IO ())
-instance WrapReturn (Ptr SX') SX where
- wrapReturn = (fmap SX) . (newForeignPtr c_delete_casadi__SX)
-
-
--- 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
-{-|
->Dynamically created function that can be expanded into a series of scalar
->operations.
->
->Joel Andersson
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| just_in_time | OT_BOOLEAN | false | Just-in-time | casadi::SXFu |
->| _opencl | | | compilation | nctionIntern |
->| | | | for numeric | al |
->| | | | evaluation | |
->| | | | using OpenCL | |
->| | | | (experimenta | |
->| | | | l) | |
->+--------------+--------------+--------------+--------------+--------------+
->| just_in_time | OT_BOOLEAN | false | Propagate | casadi::SXFu |
->| _sparsity | | | sparsity | nctionIntern |
->| | | | patterns | al |
->| | | | using just- | |
->| | | | in-time | |
->| | | | compilation | |
->| | | | to a CPU or | |
->| | | | GPU using | |
->| | | | OpenCL | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: sx_function.hpp
--}
-newtype SXFunction = SXFunction (ForeignPtr SXFunction')
--- typeclass decl
-class SXFunctionClass a where
- castSXFunction :: a -> SXFunction
-instance SXFunctionClass SXFunction where
- castSXFunction = id
-
--- baseclass instances
-instance FunctionClass SXFunction where
- castFunction (SXFunction x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SXFunction where
- castOptionsFunctionality (SXFunction x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass SXFunction where
- castPrintableObject (SXFunction x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass SXFunction where
- castSharedObject (SXFunction x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SXFunction where
- castIOInterfaceFunction (SXFunction x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SXFunction (Ptr SXFunction') where
- marshal (SXFunction x) = return (unsafeForeignPtrToPtr x)
- marshalFree (SXFunction x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SXFunction"
- c_delete_casadi__SXFunction :: FunPtr (Ptr SXFunction' -> IO ())
-instance WrapReturn (Ptr SXFunction') SXFunction where
- wrapReturn = (fmap SXFunction) . (newForeignPtr c_delete_casadi__SXFunction)
-
-
--- raw decl
-data SdpSolver'
--- data decl
-{-|
->SdpSolver.
->
->Solves an SDP problem in standard form.
->Seehttp://sdpa.indsys.chuo-u.ac.jp/sdpa/files/sdpa-c.6.2.0.manual.pdf
->
->Primal:
->
->
->
->::
->
-> min c' x
-> x
-> subject to
-> P = Sum_i^m F_i x_i - G
-> P negative semidefinite
->
-> LBA <= A x <= UBA
-> LBX <= x <= UBX
->
-> with x ( n x 1)
-> c ( n x 1 )
-> G, F_i sparse symmetric (m x m)
-> X dense symmetric ( m x m )
-> A sparse matrix ( nc x n)
-> LBA, UBA dense vector (nc x 1)
-> LBX, UBX dense vector (n x 1)
->
->
->
->This formulation is chosen as primal, because it does not call for a large
->decision variable space.
->
->Dual:
->
->
->
->::
->
-> max trace(G Y)
-> Y
->
-> subject to
-> trace(F_i Y) = c_i
-> Y positive semidefinite
->
-> with Y dense symmetric ( m x m)
->
->
->
->On generality: you might have formulation with block partitioning:
->
->Primal:
->
->
->
->::
->
-> min c' x
-> x
-> subject to
-> Pj = Sum_i^m F_ij x_i - gj for all j
-> Pj negative semidefinite for all j
->
-> with x ( n x 1)
-> c ( n x 1 )
-> G, F_i sparse symmetric (m x m)
-> X dense symmetric ( m x m )
->
->
->
->Dual:
->
->::
->
-> max Sum_j trace(Gj Yj)
-> Yj
->
-> subject to
-> Sum_j trace(F_ij Yj) = c_i for all j
-> Yj positive semidefinite for all j
->
-> with Y dense symmetric ( m x m)
->
->
->
->You can cast this into the standard form with: G = blkdiag(Gj for all j) Fi
->= blkdiag(F_ij for all j)
->
->Implementations of SdpSolver are encouraged to exploit this block structure.
->
->General information
->===================
->
->
->
->>Input scheme: casadi::SDPInput (SDP_SOLVER_NUM_IN = 8) [sdpIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| SDP_SOLVER_F | f | The horizontal stack |
->| | | of all matrices F_i: ( |
->| | | m x nm) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_C | c | The vector c: ( n x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_G | g | The matrix G: ( m x m) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_A | a | The matrix A: ( nc x |
->| | | n) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_LBA | lba | Lower bounds on Ax ( |
->| | | nc x 1) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_UBA | uba | Upper bounds on Ax ( |
->| | | nc x 1) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_LBX | lbx | Lower bounds on x ( n |
->| | | x 1 ) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_UBX | ubx | Upper bounds on x ( n |
->| | | x 1 ) . |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::SDPOutput (SDP_SOLVER_NUM_OUT = 7) [sdpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| SDP_SOLVER_X | x | The primal solution (n |
->| | | x 1) - may be used as |
->| | | initial guess . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_P | p | The solution P (m x m) |
->| | | - may be used as |
->| | | initial guess . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_DUAL | dual | The dual solution (m x |
->| | | m) - may be used as |
->| | | initial guess . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_COST | cost | The primal optimal |
->| | | cost (1 x 1) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_DUAL_COST | dual_cost | The dual optimal cost |
->| | | (1 x 1) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_LAM_A | lam_a | The dual solution |
->| | | corresponding to the |
->| | | linear constraints (nc |
->| | | x 1) . |
->+------------------------+------------------------+------------------------+
->| SDP_SOLVER_LAM_X | lam_x | The dual solution |
->| | | corresponding to |
->| | | simple bounds (n x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| calc_dual | OT_BOOLEAN | true | Indicate if | casadi::SdpS |
->| | | | dual should | olverInterna |
->| | | | be allocated | l |
->| | | | and | |
->| | | | calculated. | |
->| | | | You may want | |
->| | | | to avoid | |
->| | | | calculating | |
->| | | | this | |
->| | | | variable for | |
->| | | | problems | |
->| | | | with n | |
->| | | | large, as is | |
->| | | | always dense | |
->| | | | (m x m). | |
->+--------------+--------------+--------------+--------------+--------------+
->| calc_p | OT_BOOLEAN | true | Indicate if | casadi::SdpS |
->| | | | the P-part | olverInterna |
->| | | | of primal | l |
->| | | | solution | |
->| | | | should be | |
->| | | | allocated | |
->| | | | and | |
->| | | | calculated. | |
->| | | | You may want | |
->| | | | to avoid | |
->| | | | calculating | |
->| | | | this | |
->| | | | variable for | |
->| | | | problems | |
->| | | | with n | |
->| | | | large, as is | |
->| | | | always dense | |
->| | | | (m x m). | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| print_proble | OT_BOOLEAN | false | Print out | casadi::SdpS |
->| m | | | problem | olverInterna |
->| | | | statement | l |
->| | | | for | |
->| | | | debugging. | |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- dsdp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->SdpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->dsdp
->----
->
->
->
->Interface to the SDP solver DSDP Warning: The solver DSDP is not good at
->handling linear equalities. There are several options if you notice
->difficulties: play around with the parameter "_penalty" leave a gap
->manually switch to another SDP Solver
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| _loglevel | OT_INTEGER | 0 | An integer that |
->| | | | specifies how |
->| | | | much logging is |
->| | | | done on stdout. |
->+-----------------+-----------------+-----------------+-----------------+
->| _penalty | OT_REAL | 100000 | Penality |
->| | | | parameter |
->| | | | lambda. Must |
->| | | | exceed the |
->| | | | trace of Y. |
->| | | | This parameter |
->| | | | heavily |
->| | | | influences the |
->| | | | ability of DSDP |
->| | | | to treat linear |
->| | | | equalities. The |
->| | | | DSDP standard |
->| | | | default (1e8) |
->| | | | will make a |
->| | | | problem with |
->| | | | linear equality |
->| | | | return unusable |
->| | | | solutions. |
->+-----------------+-----------------+-----------------+-----------------+
->| _printlevel | OT_INTEGER | 1 | A printlevel of |
->| | | | zero will |
->| | | | disable all |
->| | | | output. Another |
->| | | | number |
->| | | | indicates how |
->| | | | often a line is |
->| | | | printed. |
->+-----------------+-----------------+-----------------+-----------------+
->| _reuse | OT_INTEGER | 4 | Maximum on the |
->| | | | number of times |
->| | | | the Schur |
->| | | | complement |
->| | | | matrix is |
->| | | | reused |
->+-----------------+-----------------+-----------------+-----------------+
->| _rho | OT_REAL | 4 | Potential |
->| | | | parameter. Must |
->| | | | be >=1 |
->+-----------------+-----------------+-----------------+-----------------+
->| _use_penalty | OT_BOOLEAN | true | Modifies the |
->| | | | algorithm to |
->| | | | use a penality |
->| | | | gamma on r. |
->+-----------------+-----------------+-----------------+-----------------+
->| _zbar | OT_REAL | 1.000e+10 | Initial upper |
->| | | | bound on the |
->| | | | objective of |
->| | | | the dual |
->| | | | problem. |
->+-----------------+-----------------+-----------------+-----------------+
->| dualTol | OT_REAL | 0.000 | Tolerance for |
->| | | | dual |
->| | | | infeasibility |
->| | | | (translates to |
->| | | | primal |
->| | | | infeasibility |
->| | | | in dsdp terms) |
->+-----------------+-----------------+-----------------+-----------------+
->| gapTol | OT_REAL | 0.000 | Convergence |
->| | | | criterion based |
->| | | | on distance |
->| | | | between primal |
->| | | | and dual |
->| | | | objective |
->+-----------------+-----------------+-----------------+-----------------+
->| inf | OT_REAL | 1.000e+30 | Treat numbers |
->| | | | higher than |
->| | | | this as |
->| | | | infinity |
->+-----------------+-----------------+-----------------+-----------------+
->| maxIter | OT_INTEGER | 500 | Maximum number |
->| | | | of iterations |
->+-----------------+-----------------+-----------------+-----------------+
->| primalTol | OT_REAL | 0.000 | Tolerance for |
->| | | | primal |
->| | | | infeasibility |
->| | | | (translates to |
->| | | | dual |
->| | | | infeasibility |
->| | | | in dsdp terms) |
->+-----------------+-----------------+-----------------+-----------------+
->| stepTol | OT_REAL | 0.050 | Terminate the |
->| | | | solver if the |
->| | | | step length in |
->| | | | the primal is |
->| | | | below this |
->| | | | tolerance. |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+--------------------+
->| Id |
->+====================+
->| solution_type |
->+--------------------+
->| termination_reason |
->+--------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: sdp_solver.hpp
--}
-newtype SdpSolver = SdpSolver (ForeignPtr SdpSolver')
--- typeclass decl
-class SdpSolverClass a where
- castSdpSolver :: a -> SdpSolver
-instance SdpSolverClass SdpSolver where
- castSdpSolver = id
-
--- baseclass instances
-instance FunctionClass SdpSolver where
- castFunction (SdpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SdpSolver where
- castOptionsFunctionality (SdpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass SdpSolver where
- castPrintableObject (SdpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass SdpSolver where
- castSharedObject (SdpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SdpSolver where
- castIOInterfaceFunction (SdpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SdpSolver (Ptr SdpSolver') where
- marshal (SdpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (SdpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SdpSolver"
- c_delete_casadi__SdpSolver :: FunPtr (Ptr SdpSolver' -> IO ())
-instance WrapReturn (Ptr SdpSolver') SdpSolver where
- wrapReturn = (fmap SdpSolver) . (newForeignPtr c_delete_casadi__SdpSolver)
-
-
--- raw decl
-data SdqpSolver'
--- data decl
-{-|
->SdqpSolver.
->
->Same as an SdpSolver, but with a quadratic objective 1/2 x' H x
->
->General information
->===================
->
->
->
->>Input scheme: casadi::SDQPInput (SDQP_SOLVER_NUM_IN = 9) [sdqpIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| SDQP_SOLVER_H | h | The matrix H: sparse ( |
->| | | n x n) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_C | c | The vector c: ( n x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_F | f | The horizontal stack |
->| | | of all matrices F_i: ( |
->| | | m x nm) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_G | g | The matrix G: ( m x m) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_A | a | The matrix A: ( nc x |
->| | | n) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_LBA | lba | Lower bounds on Ax ( |
->| | | nc x 1) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_UBA | uba | Upper bounds on Ax ( |
->| | | nc x 1) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_LBX | lbx | Lower bounds on x ( n |
->| | | x 1 ) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_UBX | ubx | Upper bounds on x ( n |
->| | | x 1 ) . |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::SDQPOutput (SDQP_SOLVER_NUM_OUT = 7) [sdqpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| SDQP_SOLVER_X | x | The primal solution (n |
->| | | x 1) - may be used as |
->| | | initial guess . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_P | p | The solution P (m x m) |
->| | | - may be used as |
->| | | initial guess . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_DUAL | dual | The dual solution (m x |
->| | | m) - may be used as |
->| | | initial guess . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_COST | cost | The primal optimal |
->| | | cost (1 x 1) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_DUAL_COST | dual_cost | The dual optimal cost |
->| | | (1 x 1) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_LAM_A | lam_a | The dual solution |
->| | | corresponding to the |
->| | | linear constraints (nc |
->| | | x 1) . |
->+------------------------+------------------------+------------------------+
->| SDQP_SOLVER_LAM_X | lam_x | The dual solution |
->| | | corresponding to |
->| | | simple bounds (n x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| sdp_solver | OT_STRING | GenericType( | The | casadi::Sdqp |
->| | | ) | SdqpSolver | SolverIntern |
->| | | | used to | al |
->| | | | solve the | |
->| | | | SDPs. | |
->+--------------+--------------+--------------+--------------+--------------+
->| sdp_solver_o | OT_DICTIONAR | GenericType( | Options to | casadi::Sdqp |
->| ptions | Y | ) | be passed to | SolverIntern |
->| | | | the | al |
->| | | | SDPSOlver | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- sdp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->SdqpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->sdp
->---
->
->
->
->Solve an SQDP using an SdpSolver Note: this implementation relies on
->Cholesky decomposition: Chol(H) = L -> H = LL' with L lower triangular This
->requires Pi, H to be positive definite. Positive semi-definite is not
->sufficient. Notably, H==0 will not work.
->
->A better implementation would rely on matrix square root, but we need
->singular value decomposition to implement that.
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| sdp_solver | OT_STRING | GenericType() | The SdpSolver |
->| | | | used to solve |
->| | | | the SDQPs. |
->+-----------------+-----------------+-----------------+-----------------+
->| sdp_solver_opti | OT_DICTIONARY | GenericType() | Options to be |
->| ons | | | passed to the |
->| | | | SDPSOlver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+------------------+
->| Id |
->+==================+
->| sdp_solver_stats |
->+------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: sdqp_solver.hpp
--}
-newtype SdqpSolver = SdqpSolver (ForeignPtr SdqpSolver')
--- typeclass decl
-class SdqpSolverClass a where
- castSdqpSolver :: a -> SdqpSolver
-instance SdqpSolverClass SdqpSolver where
- castSdqpSolver = id
-
--- baseclass instances
-instance FunctionClass SdqpSolver where
- castFunction (SdqpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SdqpSolver where
- castOptionsFunctionality (SdqpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass SdqpSolver where
- castPrintableObject (SdqpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass SdqpSolver where
- castSharedObject (SdqpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SdqpSolver where
- castIOInterfaceFunction (SdqpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SdqpSolver (Ptr SdqpSolver') where
- marshal (SdqpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (SdqpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SdqpSolver"
- c_delete_casadi__SdqpSolver :: FunPtr (Ptr SdqpSolver' -> IO ())
-instance WrapReturn (Ptr SdqpSolver') SdqpSolver where
- wrapReturn = (fmap SdqpSolver) . (newForeignPtr c_delete_casadi__SdqpSolver)
-
-
--- raw decl
-data SharedObject'
--- data decl
-{-|
->SharedObject implements a reference counting framework similar for efficient
->and easily-maintained memory management.
->
->To use the class, both the SharedObject class (the public class), and the
->SharedObjectNode class (the internal class) must be inherited from. It can
->be done in two different files and together with memory management, this
->approach provides a clear distinction of which methods of the class are to
->be considered "public", i.e. methods for public use that can be considered
->to remain over time with small changes, and the internal memory.
->
->When interfacing a software, which typically includes including some header
->file, this is best done only in the file where the internal class is
->defined, to avoid polluting the global namespace and other side effects.
->
->The default constructor always means creating a null pointer to an internal
->class only. To allocate an internal class (this works only when the internal
->class isn't abstract), use the constructor with arguments.
->
->The copy constructor and the assignment operator perform shallow copies
->only, to make a deep copy you must use the clone method explicitly. This
->will give a shared pointer instance.
->
->In an inheritance hierarchy, you can cast down automatically, e.g. (
->SXFunction is a child class of Function): SXFunction derived(...); Function
->base = derived;
->
->To cast up, use the shared_cast template function, which works analogously
->to dynamic_cast, static_cast, const_cast etc, e.g.: SXFunction derived(...);
->Function base = derived; SXFunction derived_from_base =
->shared_cast(base);
->
->A failed shared_cast will result in a null pointer (cf. dynamic_cast)
->
->Joel Andersson
->
->C++ includes: shared_object.hpp
--}
-newtype SharedObject = SharedObject (ForeignPtr SharedObject')
--- typeclass decl
-class SharedObjectClass a where
- castSharedObject :: a -> SharedObject
-instance SharedObjectClass SharedObject where
- castSharedObject = id
-
--- baseclass instances
-instance PrintableObjectClass SharedObject where
- castPrintableObject (SharedObject x) = PrintableObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SharedObject (Ptr SharedObject') where
- marshal (SharedObject x) = return (unsafeForeignPtrToPtr x)
- marshalFree (SharedObject x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SharedObject"
- c_delete_casadi__SharedObject :: FunPtr (Ptr SharedObject' -> IO ())
-instance WrapReturn (Ptr SharedObject') SharedObject where
- wrapReturn = (fmap SharedObject) . (newForeignPtr c_delete_casadi__SharedObject)
-
-
--- raw decl
-data Simulator'
--- data decl
-{-|
->Integrator class.
->
->An "simulator" integrates an IVP, stopping at a (fixed) number of grid
->points and evaluates a set of output functions at these points. The internal
->stepsizes of the integrator need not coincide with the gridpoints.
->
->Simulator is an casadi::Function mapping from casadi::IntegratorInput to n.
->\\\\
->
->The output function needs to be a mapping from casadi::DAEInput to n. The
->default output has n=1 and the output is the (vectorized) differential state
->for each time step.
->
->Joel Andersson
->
->>Input scheme: casadi::IntegratorInput (INTEGRATOR_NUM_IN = 6) [integratorIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| INTEGRATOR_X0 | x0 | Differential state at |
->| | | the initial time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_P | p | Parameters . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_Z0 | z0 | Initial guess for the |
->| | | algebraic variable . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RX0 | rx0 | Backward differential |
->| | | state at the final |
->| | | time . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RP | rp | Backward parameter |
->| | | vector . |
->+------------------------+------------------------+------------------------+
->| INTEGRATOR_RZ0 | rz0 | Initial guess for the |
->| | | backwards algebraic |
->| | | variable . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | casadi::Simu |
->| | | | uts) (initi | latorInterna |
->| | | | al|step) | l |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->>List of available monitors
->
->+---------+---------------------------+
->| Id | Used in |
->+=========+===========================+
->| initial | casadi::SimulatorInternal |
->+---------+---------------------------+
->| inputs | casadi::FunctionInternal |
->+---------+---------------------------+
->| outputs | casadi::FunctionInternal |
->+---------+---------------------------+
->| step | casadi::SimulatorInternal |
->+---------+---------------------------+
->
->Diagrams
->--------
->
->
->
->C++ includes: simulator.hpp
--}
-newtype Simulator = Simulator (ForeignPtr Simulator')
--- typeclass decl
-class SimulatorClass a where
- castSimulator :: a -> Simulator
-instance SimulatorClass Simulator where
- castSimulator = id
-
--- baseclass instances
-instance FunctionClass Simulator where
- castFunction (Simulator x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass Simulator where
- castOptionsFunctionality (Simulator x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass Simulator where
- castPrintableObject (Simulator x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass Simulator where
- castSharedObject (Simulator x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass Simulator where
- castIOInterfaceFunction (Simulator x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Simulator (Ptr Simulator') where
- marshal (Simulator x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Simulator x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Simulator"
- c_delete_casadi__Simulator :: FunPtr (Ptr Simulator' -> IO ())
-instance WrapReturn (Ptr Simulator') Simulator where
- wrapReturn = (fmap Simulator) . (newForeignPtr c_delete_casadi__Simulator)
-
-
--- raw decl
-data Slice'
--- data decl
-{-|
->Class representing a Slice.
->
->Note that Python or Octave do not need to use this class. They can just use
->slicing utility from the host language ( M[0:6] in Python, M(1:7) )
->
->C++ includes: slice.hpp
--}
-newtype Slice = Slice (ForeignPtr Slice')
--- typeclass decl
-class SliceClass a where
- castSlice :: a -> Slice
-instance SliceClass Slice where
- castSlice = id
-
--- baseclass instances
-instance PrintableObjectClass Slice where
- castPrintableObject (Slice x) = PrintableObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Slice (Ptr Slice') where
- marshal (Slice x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Slice x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Slice"
- c_delete_casadi__Slice :: FunPtr (Ptr Slice' -> IO ())
-instance WrapReturn (Ptr Slice') Slice where
- wrapReturn = (fmap Slice) . (newForeignPtr c_delete_casadi__Slice)
-
-
--- raw decl
-data SocpSolver'
--- data decl
-{-|
->SocpSolver.
->
->Solves an Second Order Cone Programming (SOCP) problem in standard form.
->
->Primal:
->
->
->
->::
->
-> min c' x
-> x
-> subject to
-> || Gi' x + hi ||_2 <= ei' x + fi i = 1..m
->
-> LBA <= A x <= UBA
-> LBX <= x <= UBX
->
-> with x ( n x 1)
-> c ( n x 1 )
-> Gi sparse (n x ni)
-> hi dense (ni x 1)
-> ei dense (n x 1)
-> fi dense (1 x 1)
-> N = Sum_i^m ni
-> A sparse (nc x n)
-> LBA, UBA dense vector (nc x 1)
-> LBX, UBX dense vector (n x 1)
->
->
->
->General information
->===================
->
->
->
->>Input scheme: casadi::SOCPInput (SOCP_SOLVER_NUM_IN = 10) [socpIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| SOCP_SOLVER_G | g | The horizontal stack |
->| | | of all matrices Gi: ( |
->| | | n x N) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_H | h | The vertical stack of |
->| | | all vectors hi: ( N x |
->| | | 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_E | e | The vertical stack of |
->| | | all vectors ei: ( nm x |
->| | | 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_F | f | The vertical stack of |
->| | | all scalars fi: ( m x |
->| | | 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_C | c | The vector c: ( n x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_A | a | The matrix A: ( nc x |
->| | | n) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_LBA | lba | Lower bounds on Ax ( |
->| | | nc x 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_UBA | uba | Upper bounds on Ax ( |
->| | | nc x 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_LBX | lbx | Lower bounds on x ( n |
->| | | x 1 ) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_UBX | ubx | Upper bounds on x ( n |
->| | | x 1 ) . |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::SOCPOutput (SOCP_SOLVER_NUM_OUT = 4) [socpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| SOCP_SOLVER_X | x | The primal solution (n |
->| | | x 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_COST | cost | The primal optimal |
->| | | cost (1 x 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_LAM_A | lam_a | The dual solution |
->| | | corresponding to the |
->| | | linear constraints (nc |
->| | | x 1) . |
->+------------------------+------------------------+------------------------+
->| SOCP_SOLVER_LAM_X | lam_x | The dual solution |
->| | | corresponding to |
->| | | simple bounds (n x 1) |
->| | | . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| ni | OT_INTEGERVE | GenericType( | Provide the | casadi::Socp |
->| | CTOR | ) | size of each | SolverIntern |
->| | | | SOC | al |
->| | | | constraint. | |
->| | | | Must sum up | |
->| | | | to N. | |
->+--------------+--------------+--------------+--------------+--------------+
->| print_proble | OT_BOOLEAN | false | Print out | casadi::Socp |
->| m | | | problem | SolverIntern |
->| | | | statement | al |
->| | | | for | |
->| | | | debugging. | |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- sdp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->SocpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->sdp
->---
->
->
->
->Solve SOCPs using an SdpSolver
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| sdp_solver | OT_STRING | GenericType() | The SdpSolver |
->| | | | used to solve |
->| | | | the SOCPs. |
->+-----------------+-----------------+-----------------+-----------------+
->| sdp_solver_opti | OT_DICTIONARY | GenericType() | Options to be |
->| ons | | | passed to the |
->| | | | SDPSOlver |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+------------------+
->| Id |
->+==================+
->| sdp_solver_stats |
->+------------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joris Gillis
->Diagrams
->--------
->
->
->
->C++ includes: socp_solver.hpp
--}
-newtype SocpSolver = SocpSolver (ForeignPtr SocpSolver')
--- typeclass decl
-class SocpSolverClass a where
- castSocpSolver :: a -> SocpSolver
-instance SocpSolverClass SocpSolver where
- castSocpSolver = id
-
--- baseclass instances
-instance FunctionClass SocpSolver where
- castFunction (SocpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass SocpSolver where
- castOptionsFunctionality (SocpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass SocpSolver where
- castPrintableObject (SocpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass SocpSolver where
- castSharedObject (SocpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass SocpSolver where
- castIOInterfaceFunction (SocpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal SocpSolver (Ptr SocpSolver') where
- marshal (SocpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (SocpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__SocpSolver"
- c_delete_casadi__SocpSolver :: FunPtr (Ptr SocpSolver' -> IO ())
-instance WrapReturn (Ptr SocpSolver') SocpSolver where
- wrapReturn = (fmap SocpSolver) . (newForeignPtr c_delete_casadi__SocpSolver)
-
-
--- raw decl
-data Sparsity'
--- data decl
-{-|
->General sparsity class.
->
->The storage format is a compressed column storage (CCS) format. In this
->format, the structural non-zero elements are stored in column-major order,
->starting from the upper left corner of the matrix and ending in the lower
->right corner.
->
->In addition to the dimension ( size1(), size2()), (i.e. the number of rows
->and the number of columns respectively), there are also two vectors of
->integers:
->
->"colind" [length size2()+1], which contains the index to the first non-
->zero element on or after the corresponding column. All the non-zero elements
->of a particular i are thus the elements with index el that fulfills:
->colind[i] <= el < colind[i+1].
->
->"row" [same length as the number of non-zero elements, size()] The rows
->for each of the structural non-zeros.
->
->Note that with this format, it is cheap to loop over all the non-zero
->elements of a particular column, at constant time per element, but expensive
->to jump to access a location (i, j).
->
->If the matrix is dense, i.e. length(row) == size1()*size2(), the format
->reduces to standard dense column major format, which allows access to an
->arbitrary element in constant time.
->
->Since the object is reference counted (it inherits from SharedObject),
->several matrices are allowed to share the same sparsity pattern.
->
->The implementations of some methods of this class has been taken from the
->CSparse package and modified to use C++ standard library and CasADi data
->structures.
->
->See: Matrix
->
->Joel Andersson
->
->C++ includes: sparsity.hpp
--}
-newtype Sparsity = Sparsity (ForeignPtr Sparsity')
--- typeclass decl
-class SparsityClass a where
- castSparsity :: a -> Sparsity
-instance SparsityClass Sparsity where
- castSparsity = id
-
--- baseclass instances
-instance PrintableObjectClass Sparsity where
- castPrintableObject (Sparsity x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass Sparsity where
- castSharedObject (Sparsity x) = SharedObject (castForeignPtr x)
-
-
--- helper instances
-instance Marshal Sparsity (Ptr Sparsity') where
- marshal (Sparsity x) = return (unsafeForeignPtrToPtr x)
- marshalFree (Sparsity x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__Sparsity"
- c_delete_casadi__Sparsity :: FunPtr (Ptr Sparsity' -> IO ())
-instance WrapReturn (Ptr Sparsity') Sparsity where
- wrapReturn = (fmap Sparsity) . (newForeignPtr c_delete_casadi__Sparsity)
-
-
--- raw decl
-data StabilizedQpSolver'
--- data decl
-{-|
->StabilizedQpSolver.
->
->Solves the following strictly convex problem:
->
->
->
->::
->
-> min 1/2 x' H x + g' x
-> x
->
-> subject to
-> LBA <= A x <= UBA
-> LBX <= x <= UBX
->
-> with :
-> H sparse (n x n) positive definite
-> g dense (n x 1)
->
-> n: number of decision variables (x)
-> nc: number of constraints (A)
->
->
->
->If H is not positive-definite, the solver should throw an error.
->
->General information
->===================
->
->
->
->>Input scheme: casadi::StabilizedQpSolverInput (STABILIZED_QP_SOLVER_NUM_IN = 12) [stabilizedQpIn]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| STABILIZED_QP_SOLVER_H | h | The square matrix H: |
->| | | sparse, (n x n). Only |
->| | | the lower triangular |
->| | | part is actually used. |
->| | | The matrix is assumed |
->| | | to be symmetrical. |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_G | g | The vector g: dense, |
->| | | (n x 1) . |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_A | a | The matrix A: sparse, |
->| | | (nc x n) - product |
->| | | with x must be dense. |
->| | | . |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_L | lba | dense, (nc x 1) |
->| BA | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_U | uba | dense, (nc x 1) |
->| BA | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_L | lbx | dense, (n x 1) |
->| BX | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_U | ubx | dense, (n x 1) |
->| BX | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_X | x0 | dense, (n x 1) |
->| 0 | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_L | lam_x0 | dense |
->| AM_X0 | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_M | muR | dense (1 x 1) |
->| UR | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_M | muE | dense (nc x 1) |
->| UE | | |
->+------------------------+------------------------+------------------------+
->| STABILIZED_QP_SOLVER_M | mu | dense (nc x 1) |
->| U | | |
->+------------------------+------------------------+------------------------+
->
->>Output scheme: casadi::QpSolverOutput (QP_SOLVER_NUM_OUT = 4) [qpOut]
->
->+------------------------+------------------------+------------------------+
->| Full name | Short | Description |
->+========================+========================+========================+
->| QP_SOLVER_X | x | The primal solution . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_COST | cost | The optimal cost . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_LAM_A | lam_a | The dual solution |
->| | | corresponding to |
->| | | linear bounds . |
->+------------------------+------------------------+------------------------+
->| QP_SOLVER_LAM_X | lam_x | The dual solution |
->| | | corresponding to |
->| | | simple bounds . |
->+------------------------+------------------------+------------------------+
->
->>List of available options
->
->+--------------+--------------+--------------+--------------+--------------+
->| Id | Type | Default | Description | Used in |
->+==============+==============+==============+==============+==============+
->| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
->| | | | calculate | tionInternal |
->| | | | the | |
->| | | | Jacobians. | |
->| | | | (forward: | |
->| | | | only forward | |
->| | | | mode|reverse | |
->| | | | : only | |
->| | | | adjoint mode | |
->| | | | |automatic: | |
->| | | | a heuristic | |
->| | | | decides | |
->| | | | which is | |
->| | | | more | |
->| | | | appropriate) | |
->+--------------+--------------+--------------+--------------+--------------+
->| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
->| enerator | EGENERATOR | ) | that returns | tionInternal |
->| | | | a derivative | |
->| | | | function | |
->| | | | given a | |
->| | | | number of | |
->| | | | forward and | |
->| | | | reverse | |
->| | | | directional | |
->| | | | derivative, | |
->| | | | overrides | |
->| | | | internal | |
->| | | | routines. | |
->| | | | Check docume | |
->| | | | ntation of D | |
->| | | | erivativeGen | |
->| | | | erator . | |
->+--------------+--------------+--------------+--------------+--------------+
->| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
->| | | | indicate | tionInternal |
->| | | | whether | |
->| | | | statistics | |
->| | | | must be | |
->| | | | gathered | |
->+--------------+--------------+--------------+--------------+--------------+
->| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
->| | | | exceptions | tionInternal |
->| | | | when the | |
->| | | | numerical | |
->| | | | values of | |
->| | | | the inputs | |
->| | | | don't make | |
->| | | | sense | |
->+--------------+--------------+--------------+--------------+--------------+
->| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
->| | TOR | ) | be activated | tionInternal |
->| | | | (inputs|outp | |
->| | | | uts) | |
->+--------------+--------------+--------------+--------------+--------------+
->| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
->| | | red_object" | object | onsFunctiona |
->| | | | | lityNode |
->+--------------+--------------+--------------+--------------+--------------+
->| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
->| heck | | | exceptions | tionInternal |
->| | | | when NaN or | |
->| | | | Inf appears | |
->| | | | during | |
->| | | | evaluation | |
->+--------------+--------------+--------------+--------------+--------------+
->| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
->| | | ) | defined | tionInternal |
->| | | | field that | |
->| | | | can be used | |
->| | | | to identify | |
->| | | | the function | |
->| | | | or pass | |
->| | | | additional | |
->| | | | information | |
->+--------------+--------------+--------------+--------------+--------------+
->| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
->| | | | evaluation | tionInternal |
->| | | | for | |
->| | | | debugging | |
->+--------------+--------------+--------------+--------------+--------------+
->
->List of plugins
->===============
->
->
->
->- sqic
->
->- qp
->
->Note: some of the plugins in this list might not be available on your
->system. Also, there might be extra plugins available to you that are not
->listed here. You can obtain their documentation with
->StabilizedQpSolver.doc("myextraplugin")
->
->
->
->--------------------------------------------------------------------------------
->
->sqic
->----
->
->
->
->Interface to SQIC
->
->>List of available options
->
->+----+------+---------+-------------+
->| Id | Type | Default | Description |
->+====+======+=========+=============+
->+----+------+---------+-------------+
->
->--------------------------------------------------------------------------------
->
->
->
->--------------------------------------------------------------------------------
->
->qp --
->
->
->
->Solved a stabilized QP using a standard QP solver
->
->>List of available options
->
->+-----------------+-----------------+-----------------+-----------------+
->| Id | Type | Default | Description |
->+=================+=================+=================+=================+
->| qp_solver | OT_STRING | GenericType() | The QP solver |
->| | | | used to solve |
->| | | | the stabilized |
->| | | | QPs. |
->+-----------------+-----------------+-----------------+-----------------+
->| qp_solver_optio | OT_DICTIONARY | GenericType() | Options to be |
->| ns | | | passed to the |
->| | | | QP solver |
->| | | | instance |
->+-----------------+-----------------+-----------------+-----------------+
->
->>List of available stats
->
->+-----------------+
->| Id |
->+=================+
->| qp_solver_stats |
->+-----------------+
->
->--------------------------------------------------------------------------------
->
->
->
->Joel Andersson
->Diagrams
->--------
->
->
->
->C++ includes: stabilized_qp_solver.hpp
--}
-newtype StabilizedQpSolver = StabilizedQpSolver (ForeignPtr StabilizedQpSolver')
--- typeclass decl
-class StabilizedQpSolverClass a where
- castStabilizedQpSolver :: a -> StabilizedQpSolver
-instance StabilizedQpSolverClass StabilizedQpSolver where
- castStabilizedQpSolver = id
-
--- baseclass instances
-instance FunctionClass StabilizedQpSolver where
- castFunction (StabilizedQpSolver x) = Function (castForeignPtr x)
-
-instance OptionsFunctionalityClass StabilizedQpSolver where
- castOptionsFunctionality (StabilizedQpSolver x) = OptionsFunctionality (castForeignPtr x)
-
-instance PrintableObjectClass StabilizedQpSolver where
- castPrintableObject (StabilizedQpSolver x) = PrintableObject (castForeignPtr x)
-
-instance SharedObjectClass StabilizedQpSolver where
- castSharedObject (StabilizedQpSolver x) = SharedObject (castForeignPtr x)
-
-instance IOInterfaceFunctionClass StabilizedQpSolver where
- castIOInterfaceFunction (StabilizedQpSolver x) = IOInterfaceFunction (castForeignPtr x)
-
-
--- helper instances
-instance Marshal StabilizedQpSolver (Ptr StabilizedQpSolver') where
- marshal (StabilizedQpSolver x) = return (unsafeForeignPtrToPtr x)
- marshalFree (StabilizedQpSolver x) _ = touchForeignPtr x
-foreign import ccall unsafe "&delete_casadi__StabilizedQpSolver"
- c_delete_casadi__StabilizedQpSolver :: FunPtr (Ptr StabilizedQpSolver' -> IO ())
-instance WrapReturn (Ptr StabilizedQpSolver') StabilizedQpSolver where
- wrapReturn = (fmap StabilizedQpSolver) . (newForeignPtr c_delete_casadi__StabilizedQpSolver)
-
-
--- raw decl
-data SymbolicNLP'
--- data decl
-{-|
->A symbolic NLP representation.
->
->Joel Andersson
->
->C++ includes: symbolic_nlp.hpp
--}
-newtype SymbolicNLP = SymbolicNLP (ForeignPtr SymbolicNLP')
--- typeclass decl
-class SymbolicNLPClass a where
- castSymbolicNLP :: a -> SymbolicNLP
-instance SymbolicNLPClass SymbolicNLP where
- castSymbolicNLP = id
-
--- baseclass instances
-instance PrintableObjectClass SymbolicNLP where
- castPrintableObject (SymbolicNLP x) = PrintableObject (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 SharedObjectClass Callback where
+ castSharedObject (Callback x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Callback (Ptr Callback') where
+ marshal (Callback x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Callback x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Callback"
+ c_delete_casadi__Callback :: FunPtr (Ptr Callback' -> IO ())
+instance WrapReturn (Ptr Callback') Callback where
+ wrapReturn = (fmap Callback) . (newForeignPtr c_delete_casadi__Callback)
+
+
+-- raw decl
+data CasadiMeta'
+-- data decl
+{-|
+>Collects global CasADi meta information.
+>
+>Joris Gillis
+>
+>C++ includes: casadi_meta.hpp
+-}
+newtype CasadiMeta = CasadiMeta (ForeignPtr CasadiMeta')
+-- typeclass decl
+class CasadiMetaClass a where
+ castCasadiMeta :: a -> CasadiMeta
+instance CasadiMetaClass CasadiMeta where
+ castCasadiMeta = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal CasadiMeta (Ptr CasadiMeta') where
+ marshal (CasadiMeta x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (CasadiMeta x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__CasadiMeta"
+ c_delete_casadi__CasadiMeta :: FunPtr (Ptr CasadiMeta' -> IO ())
+instance WrapReturn (Ptr CasadiMeta') CasadiMeta where
+ wrapReturn = (fmap CasadiMeta) . (newForeignPtr c_delete_casadi__CasadiMeta)
+
+
+-- raw decl
+data CasadiOptions'
+-- data decl
+{-|
+>Collects global CasADi options.
+>
+>Note to developers: use sparingly. Global options are - in general - a
+>rather bad idea
+>
+>this class must never be instantiated. Access its static members directly
+>Joris Gillis
+>
+>C++ includes: casadi_options.hpp
+-}
+newtype CasadiOptions = CasadiOptions (ForeignPtr CasadiOptions')
+-- typeclass decl
+class CasadiOptionsClass a where
+ castCasadiOptions :: a -> CasadiOptions
+instance CasadiOptionsClass CasadiOptions where
+ castCasadiOptions = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal CasadiOptions (Ptr CasadiOptions') where
+ marshal (CasadiOptions x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (CasadiOptions x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__CasadiOptions"
+ c_delete_casadi__CasadiOptions :: FunPtr (Ptr CasadiOptions' -> IO ())
+instance WrapReturn (Ptr CasadiOptions') CasadiOptions where
+ wrapReturn = (fmap CasadiOptions) . (newForeignPtr c_delete_casadi__CasadiOptions)
+
+
+-- raw decl
+data CleSolver'
+-- data decl
+{-|
+>Base class for Discrete Lyapunov Equation Solvers.
+>
+>Given matrices $A$ and symmetric $V$
+>
+>
+>
+>::
+>
+> A in R^(n x n)
+> V in S^n
+>
+>
+>
+>
+>finds $P$ that satisfies:
+>
+>
+>
+>::
+>
+> 0 = A P + P A' + V
+>
+>
+>
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::CLEInput (CLE_NUM_IN = 2) [cleIn]
+>
+>+-----------+-------+-------------+
+>| Full name | Short | Description |
+>+===========+=======+=============+
+>| CLE_A | a | A matrix . |
+>+-----------+-------+-------------+
+>| CLE_V | v | V matrix . |
+>+-----------+-------+-------------+
+>
+>>Output scheme: casadi::CLEOutput (CLE_NUM_OUT = 1) [cleOut]
+>
+>+-----------+-------+-------------------+
+>| Full name | Short | Description |
+>+===========+=======+===================+
+>| CLE_P | p | Lyapunov matrix . |
+>+-----------+-------+-------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| eps_unstable | OT_REAL | 0.000 | A margin for | casadi::CleI |
+>| | | | unstability | nternal |
+>| | | | detection | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| error_unstab | OT_BOOLEAN | false | Throw an | casadi::CleI |
+>| le | | | exception | nternal |
+>| | | | when it is | |
+>| | | | detected | |
+>| | | | that | |
+>| | | | Product(A_i, | |
+>| | | | i=N..1) has | |
+>| | | | eigenvalues | |
+>| | | | greater than | |
+>| | | | 1-eps_unstab | |
+>| | | | le | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| pos_def | OT_BOOLEAN | false | Assume P | casadi::CleI |
+>| | | | positive | nternal |
+>| | | | definite | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- simple
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>CleSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>simple
+>------
+>
+>
+>
+>Solving the Discrete Lyapunov Equations with a regular LinearSolver
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| linear_solver | OT_STRING | GenericType() | User-defined |
+>| | | | linear solver |
+>| | | | class. Needed |
+>| | | | for |
+>| | | | sensitivities. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptions | | | passed to the |
+>| | | | linear solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: cle_solver.hpp
+-}
+newtype CleSolver = CleSolver (ForeignPtr CleSolver')
+-- typeclass decl
+class CleSolverClass a where
+ castCleSolver :: a -> CleSolver
+instance CleSolverClass CleSolver where
+ castCleSolver = id
+
+-- baseclass instances
+instance FunctionClass CleSolver where
+ castFunction (CleSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass CleSolver where
+ castOptionsFunctionality (CleSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass CleSolver where
+ castSharedObject (CleSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass CleSolver where
+ castIOInterfaceFunction (CleSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal CleSolver (Ptr CleSolver') where
+ marshal (CleSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (CleSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__CleSolver"
+ c_delete_casadi__CleSolver :: FunPtr (Ptr CleSolver' -> IO ())
+instance WrapReturn (Ptr CleSolver') CleSolver where
+ wrapReturn = (fmap CleSolver) . (newForeignPtr c_delete_casadi__CleSolver)
+
+
+-- raw decl
+data ControlSimulator'
+-- data decl
+{-|
+>Piecewise Simulation class.
+>
+>A ControlSimulator can be seen as a chain of Simulators whereby some
+>parameters change from one Simulator to the next.
+>
+>These changing parameters can typically be interpreted as "controls" in
+>the context of dynamic optimization.
+>
+>We discriminate between the following time steps: Major time-steps. These
+>are the time steps provided by the supplied grid. Controls are constant
+>inbetween major time-steps Minor time-steps. These are time steps linearly
+>interpolated from one major time-step to the next. The option 'nf' regulates
+>how many minor time-steps are taken. Integration time-steps. Time steps
+>that the supplied integrator might choose to integrate the continuous
+>dynamics. They are not important what ControlSimulator is concerned. np
+>Number of parameters nu Number of controls ns The number of major grid
+>points, as supplied in the constructor nf The number of minor grid points
+>per major interval
+>
+>Joris Gillis
+>
+>>Input scheme: casadi::ControlSimulatorInput (CONTROLSIMULATOR_NUM_IN = 3) [controlsimulatorIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| CONTROLSIMULATOR_X0 | x0 | Differential or |
+>| | | algebraic state at t0 |
+>| | | (dimension nx-by-1) . |
+>+------------------------+------------------------+------------------------+
+>| CONTROLSIMULATOR_P | p | Parameters that are |
+>| | | fixed over the entire |
+>| | | horizon (dimension np- |
+>| | | by-1) . |
+>+------------------------+------------------------+------------------------+
+>| CONTROLSIMULATOR_U | u | Parameters that change |
+>| | | over the integration |
+>| | | intervals (dimension |
+>| | | nu-by-(ns-1)) . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| control_endp | OT_BOOLEAN | false | Include a | casadi::Cont |
+>| oint | | | control | rolSimulator |
+>| | | | value at the | Internal |
+>| | | | end of the | |
+>| | | | simulation | |
+>| | | | domain. Used | |
+>| | | | for interpol | |
+>| | | | ation. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| control_inte | OT_STRING | "none" | none|nearest | casadi::Cont |
+>| rpolation | | | |linear | rolSimulator |
+>| | | | | Internal |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| integrator | OT_STRING | GenericType( | An | casadi::Cont |
+>| | | ) | integrator | rolSimulator |
+>| | | | creator | Internal |
+>| | | | function | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| integrator_o | OT_DICTIONAR | GenericType( | Options to | casadi::Cont |
+>| ptions | Y | ) | be passed to | rolSimulator |
+>| | | | the | Internal |
+>| | | | integrator | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| minor_grid | OT_INTEGERVE | GenericType( | The local | casadi::Cont |
+>| | CTOR | ) | grid used on | rolSimulator |
+>| | | | each major | Internal |
+>| | | | interval, | |
+>| | | | with time | |
+>| | | | normalized | |
+>| | | | to 1. By | |
+>| | | | default, | |
+>| | | | option 'nf' | |
+>| | | | is used to | |
+>| | | | construct a | |
+>| | | | linearly | |
+>| | | | spaced grid. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| nf | OT_INTEGER | 1 | Number of | casadi::Cont |
+>| | | | minor | rolSimulator |
+>| | | | grained | Internal |
+>| | | | integration | |
+>| | | | steps per | |
+>| | | | major | |
+>| | | | interval. | |
+>| | | | nf>0 must | |
+>| | | | hold. This | |
+>| | | | option is | |
+>| | | | not used | |
+>| | | | when | |
+>| | | | 'minor_grid' | |
+>| | | | is provided. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| simulator_op | OT_DICTIONAR | GenericType( | Options to | casadi::Cont |
+>| tions | Y | ) | be passed to | rolSimulator |
+>| | | | the | Internal |
+>| | | | simulator | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: control_simulator.hpp
+-}
+newtype ControlSimulator = ControlSimulator (ForeignPtr ControlSimulator')
+-- typeclass decl
+class ControlSimulatorClass a where
+ castControlSimulator :: a -> ControlSimulator
+instance ControlSimulatorClass ControlSimulator where
+ castControlSimulator = id
+
+-- baseclass instances
+instance FunctionClass ControlSimulator where
+ castFunction (ControlSimulator x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass ControlSimulator where
+ castOptionsFunctionality (ControlSimulator x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass ControlSimulator where
+ castSharedObject (ControlSimulator x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass ControlSimulator where
+ castIOInterfaceFunction (ControlSimulator x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal ControlSimulator (Ptr ControlSimulator') where
+ marshal (ControlSimulator x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (ControlSimulator x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__ControlSimulator"
+ c_delete_casadi__ControlSimulator :: FunPtr (Ptr ControlSimulator' -> IO ())
+instance WrapReturn (Ptr ControlSimulator') ControlSimulator where
+ wrapReturn = (fmap ControlSimulator) . (newForeignPtr c_delete_casadi__ControlSimulator)
+
+
+-- raw decl
+data CustomEvaluate'
+-- data decl
+{-|
+>CustomEvaluate.
+>
+>In C++, supply a CustomEvaluateCPtr function pointer
+>
+>In python, supply a callable, annotated with pyevaluate decorator
+>
+>C++ includes: functor.hpp
+-}
+newtype CustomEvaluate = CustomEvaluate (ForeignPtr CustomEvaluate')
+-- typeclass decl
+class CustomEvaluateClass a where
+ castCustomEvaluate :: a -> CustomEvaluate
+instance CustomEvaluateClass CustomEvaluate where
+ castCustomEvaluate = id
+
+-- baseclass instances
+instance FunctorClass CustomEvaluate where
+ castFunctor (CustomEvaluate x) = Functor (castForeignPtr x)
+
+instance SharedObjectClass CustomEvaluate where
+ castSharedObject (CustomEvaluate x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal CustomEvaluate (Ptr CustomEvaluate') where
+ marshal (CustomEvaluate x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (CustomEvaluate x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__CustomEvaluate"
+ c_delete_casadi__CustomEvaluate :: FunPtr (Ptr CustomEvaluate' -> IO ())
+instance WrapReturn (Ptr CustomEvaluate') CustomEvaluate where
+ wrapReturn = (fmap CustomEvaluate) . (newForeignPtr c_delete_casadi__CustomEvaluate)
+
+
+-- raw decl
+data CustomFunction'
+-- data decl
+{-|
+>Interface to a custom function.
+>
+>Joel Andersson
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: custom_function.hpp
+-}
+newtype CustomFunction = CustomFunction (ForeignPtr CustomFunction')
+-- typeclass decl
+class CustomFunctionClass a where
+ castCustomFunction :: a -> CustomFunction
+instance CustomFunctionClass CustomFunction where
+ castCustomFunction = id
+
+-- baseclass instances
+instance FunctionClass CustomFunction where
+ castFunction (CustomFunction x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass CustomFunction where
+ castOptionsFunctionality (CustomFunction x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass CustomFunction where
+ castSharedObject (CustomFunction x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass CustomFunction where
+ castIOInterfaceFunction (CustomFunction x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal CustomFunction (Ptr CustomFunction') where
+ marshal (CustomFunction x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (CustomFunction x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__CustomFunction"
+ c_delete_casadi__CustomFunction :: FunPtr (Ptr CustomFunction' -> IO ())
+instance WrapReturn (Ptr CustomFunction') CustomFunction where
+ wrapReturn = (fmap CustomFunction) . (newForeignPtr c_delete_casadi__CustomFunction)
+
+
+-- raw decl
+data DMatrix'
+-- data decl
+{-|
+-}
+newtype DMatrix = DMatrix (ForeignPtr DMatrix')
+-- typeclass decl
+class DMatrixClass a where
+ castDMatrix :: a -> DMatrix
+instance DMatrixClass DMatrix where
+ castDMatrix = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal DMatrix (Ptr DMatrix') where
+ marshal (DMatrix x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (DMatrix x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__DMatrix"
+ c_delete_casadi__DMatrix :: FunPtr (Ptr DMatrix' -> IO ())
+instance WrapReturn (Ptr DMatrix') DMatrix where
+ wrapReturn = (fmap DMatrix) . (newForeignPtr c_delete_casadi__DMatrix)
+
+
+-- raw decl
+data DerivativeGenerator'
+-- data decl
+{-|
+>Derivative Generator Functor.
+>
+>In C++, supply a DerivativeGeneratorCPtr function pointer
+>
+>In python, supply a callable, annotated with derivativegenerator decorator
+>
+>C++ includes: functor.hpp
+-}
+newtype DerivativeGenerator = DerivativeGenerator (ForeignPtr DerivativeGenerator')
+-- typeclass decl
+class DerivativeGeneratorClass a where
+ castDerivativeGenerator :: a -> DerivativeGenerator
+instance DerivativeGeneratorClass DerivativeGenerator where
+ castDerivativeGenerator = id
+
+-- baseclass instances
+instance FunctorClass DerivativeGenerator where
+ castFunctor (DerivativeGenerator x) = Functor (castForeignPtr x)
+
+instance SharedObjectClass DerivativeGenerator where
+ castSharedObject (DerivativeGenerator x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal DerivativeGenerator (Ptr DerivativeGenerator') where
+ marshal (DerivativeGenerator x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (DerivativeGenerator x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__DerivativeGenerator"
+ c_delete_casadi__DerivativeGenerator :: FunPtr (Ptr DerivativeGenerator' -> IO ())
+instance WrapReturn (Ptr DerivativeGenerator') DerivativeGenerator where
+ wrapReturn = (fmap DerivativeGenerator) . (newForeignPtr c_delete_casadi__DerivativeGenerator)
+
+
+-- raw decl
+data DleSolver'
+-- data decl
+{-|
+>Base class for Discrete Lyapunov Equation Solvers.
+>
+>Given matrices $A$ and symmetric $V$
+>
+>
+>
+>::
+>
+> A in R^(n x n)
+> V in S^n
+>
+>
+>
+>
+>finds $P$ that satisfies:
+>
+>
+>
+>::
+>
+> P = A P A' + V
+>
+>
+>
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::DLEInput (DLE_NUM_IN = 2) [dleIn]
+>
+>+-----------+-------+-------------+
+>| Full name | Short | Description |
+>+===========+=======+=============+
+>| DLE_A | a | A matrix . |
+>+-----------+-------+-------------+
+>| DLE_V | v | V matrix . |
+>+-----------+-------+-------------+
+>
+>>Output scheme: casadi::DLEOutput (DLE_NUM_OUT = 1) [dleOut]
+>
+>+-----------+-------+-------------+
+>| Full name | Short | Description |
+>+===========+=======+=============+
+>| DLE_P | p | P matrix . |
+>+-----------+-------+-------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| eps_unstable | OT_REAL | 0.000 | A margin for | casadi::DleI |
+>| | | | unstability | nternal |
+>| | | | detection | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| error_unstab | OT_BOOLEAN | false | Throw an | casadi::DleI |
+>| le | | | exception | nternal |
+>| | | | when it is | |
+>| | | | detected | |
+>| | | | that | |
+>| | | | Product(A_i, | |
+>| | | | i=N..1) has | |
+>| | | | eigenvalues | |
+>| | | | greater than | |
+>| | | | 1-eps_unstab | |
+>| | | | le | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| pos_def | OT_BOOLEAN | false | Assume P | casadi::DleI |
+>| | | | positive | nternal |
+>| | | | definite | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- dple
+>
+>- fixed_smith
+>
+>- lrdle
+>
+>- simple
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>DleSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>dple
+>----
+>
+>
+>
+>Solving the Discrete Lyapunov Equations with Periodic Solver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>fixed_smith
+>-----------
+>
+>
+>
+>Solving the Discrete Lyapunov Equations with a fixed number of smith
+>iterations.
+>
+>DleSolversmith
+>
+>>List of available options
+>
+>+---------------+------------+---------+----------------------------+
+>| Id | Type | Default | Description |
+>+===============+============+=========+============================+
+>| freq_doubling | OT_BOOLEAN | false | Use frequency doubling |
+>+---------------+------------+---------+----------------------------+
+>| iter | OT_INTEGER | 100 | Number of Smith iterations |
+>+---------------+------------+---------+----------------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>lrdle
+>-----
+>
+>
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>simple
+>------
+>
+>
+>
+>Solving the Discrete Lyapunov Equations with a regular LinearSolver
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| compressed_solv | OT_BOOLEAN | true | When a system |
+>| e | | | with sparse rhs |
+>| | | | arises, |
+>| | | | compress toa |
+>| | | | smaller system |
+>| | | | with dense rhs. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver | OT_STRING | GenericType() | User-defined |
+>| | | | linear solver |
+>| | | | class. Needed |
+>| | | | for |
+>| | | | sensitivities. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptions | | | passed to the |
+>| | | | linear solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: dle_solver.hpp
+-}
+newtype DleSolver = DleSolver (ForeignPtr DleSolver')
+-- typeclass decl
+class DleSolverClass a where
+ castDleSolver :: a -> DleSolver
+instance DleSolverClass DleSolver where
+ castDleSolver = id
+
+-- baseclass instances
+instance FunctionClass DleSolver where
+ castFunction (DleSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass DleSolver where
+ castOptionsFunctionality (DleSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass DleSolver where
+ castSharedObject (DleSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass DleSolver where
+ castIOInterfaceFunction (DleSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal DleSolver (Ptr DleSolver') where
+ marshal (DleSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (DleSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__DleSolver"
+ c_delete_casadi__DleSolver :: FunPtr (Ptr DleSolver' -> IO ())
+instance WrapReturn (Ptr DleSolver') DleSolver where
+ wrapReturn = (fmap DleSolver) . (newForeignPtr c_delete_casadi__DleSolver)
+
+
+-- raw decl
+data DpleSolver'
+-- data decl
+{-|
+>Base class for Discrete Periodic Lyapunov Equation Solvers.
+>
+>Given matrices $A_k$ and symmetric $V_k, k = 0..K-1$
+>
+>
+>
+>::
+>
+> A_k in R^(n x n)
+> V_k in R^n
+>
+>
+>
+>
+>provides all of $P_k$ that satisfy:
+>
+>
+>
+>::
+>
+> P_0 = A_(K-1)*P_(K-1)*A_(K-1)' + V_k
+> P_k+1 = A_k*P_k*A_k' + V_k for k = 1..K-1
+>
+>
+>
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::DPLEInput (DPLE_NUM_IN = 2) [dpleIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| DPLE_A | a | A matrices (horzcat |
+>| | | when const_dim, |
+>| | | blkdiag otherwise) . |
+>+------------------------+------------------------+------------------------+
+>| DPLE_V | v | V matrices (horzcat |
+>| | | when const_dim, |
+>| | | blkdiag otherwise) . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::DPLEOutput (DPLE_NUM_OUT = 1) [dpleOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| DPLE_P | p | Lyapunov matrix |
+>| | | (horzcat when |
+>| | | const_dim, blkdiag |
+>| | | otherwise) (Cholesky |
+>| | | of P if pos_def) . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| const_dim | OT_BOOLEAN | true | Assume | casadi::Dple |
+>| | | | constant | Internal |
+>| | | | dimension of | |
+>| | | | P | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| eps_unstable | OT_REAL | 0.000 | A margin for | casadi::Dple |
+>| | | | unstability | Internal |
+>| | | | detection | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| error_unstab | OT_BOOLEAN | false | Throw an | casadi::Dple |
+>| le | | | exception | Internal |
+>| | | | when it is | |
+>| | | | detected | |
+>| | | | that | |
+>| | | | Product(A_i, | |
+>| | | | i=N..1) has | |
+>| | | | eigenvalues | |
+>| | | | greater than | |
+>| | | | 1-eps_unstab | |
+>| | | | le | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| pos_def | OT_BOOLEAN | false | Assume P | casadi::Dple |
+>| | | | positive | Internal |
+>| | | | definite | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- slicot
+>
+>- condensing
+>
+>- lifting
+>
+>- lrdple
+>
+>- simple
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>DpleSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>slicot
+>------
+>
+>
+>
+>An efficient solver for Discrete Periodic Lyapunov Equations using SLICOT
+>
+>Uses Periodic Schur Decomposition ('psd') and does not assume positive
+>definiteness. Based on Periodic Lyapunov equations: some applications and
+>new algorithms. Int. J. Control, vol. 67, pp. 69-87, 1997.
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| linear_solver | OT_STRING | GenericType() | User-defined |
+>| | | | linear solver |
+>| | | | class. Needed |
+>| | | | for |
+>| | | | sensitivities. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptions | | | passed to the |
+>| | | | linear solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| psd_num_zero | OT_REAL | 0.000 | Numerical zero |
+>| | | | used in |
+>| | | | Periodic Schur |
+>| | | | decomposition |
+>| | | | with |
+>| | | | slicot.This |
+>| | | | option is |
+>| | | | needed when |
+>| | | | your systems |
+>| | | | has Floquet |
+>| | | | multiplierszero |
+>| | | | or close to |
+>| | | | zero |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available stats
+>
+>+----------------+
+>| Id |
+>+================+
+>| t_linear_solve |
+>+----------------+
+>| t_psd |
+>+----------------+
+>| t_total |
+>+----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>condensing
+>----------
+>
+>
+>
+>Solving the Discrete Periodic Lyapunov Equations by condensing the entire
+>period to a single Discrete Lyapunov Equation
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>lifting
+>-------
+>
+>
+>
+>Solving the Discrete Periodic Lyapunov Equations by lifting the entire
+>period to a single Discrete Lyapunov Equation
+>
+>>List of available options
+>
+>+------+-----------+---------+-----------------------------------+
+>| Id | Type | Default | Description |
+>+======+===========+=========+===================================+
+>| form | OT_STRING | "A" | The form of the lifting (A:0|B:1) |
+>+------+-----------+---------+-----------------------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>lrdple
+>------
+>
+>
+>
+>Solving the Low-Rank Discrete Lyapunov Equations with a Low-Rank Discrete
+>Lyapunov Equations Solver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>simple
+>------
+>
+>
+>
+>Solving the Discrete Periodic Lyapunov Equations with a regular LinearSolver
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| linear_solver | OT_STRING | GenericType() | User-defined |
+>| | | | linear solver |
+>| | | | class. Needed |
+>| | | | for |
+>| | | | sensitivities. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptions | | | passed to the |
+>| | | | linear solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: dple_solver.hpp
+-}
+newtype DpleSolver = DpleSolver (ForeignPtr DpleSolver')
+-- typeclass decl
+class DpleSolverClass a where
+ castDpleSolver :: a -> DpleSolver
+instance DpleSolverClass DpleSolver where
+ castDpleSolver = id
+
+-- baseclass instances
+instance FunctionClass DpleSolver where
+ castFunction (DpleSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass DpleSolver where
+ castOptionsFunctionality (DpleSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass DpleSolver where
+ castSharedObject (DpleSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass DpleSolver where
+ castIOInterfaceFunction (DpleSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal DpleSolver (Ptr DpleSolver') where
+ marshal (DpleSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (DpleSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__DpleSolver"
+ c_delete_casadi__DpleSolver :: FunPtr (Ptr DpleSolver' -> IO ())
+instance WrapReturn (Ptr DpleSolver') DpleSolver where
+ wrapReturn = (fmap DpleSolver) . (newForeignPtr c_delete_casadi__DpleSolver)
+
+
+-- raw decl
+data ExternalFunction'
+-- data decl
+{-|
+>Interface for a function that is not implemented by CasADi symbolics.
+>
+>Joel Andersson
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: external_function.hpp
+-}
+newtype ExternalFunction = ExternalFunction (ForeignPtr ExternalFunction')
+-- typeclass decl
+class ExternalFunctionClass a where
+ castExternalFunction :: a -> ExternalFunction
+instance ExternalFunctionClass ExternalFunction where
+ castExternalFunction = id
+
+-- baseclass instances
+instance FunctionClass ExternalFunction where
+ castFunction (ExternalFunction x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass ExternalFunction where
+ castOptionsFunctionality (ExternalFunction x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass ExternalFunction where
+ castSharedObject (ExternalFunction x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass ExternalFunction where
+ castIOInterfaceFunction (ExternalFunction x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal ExternalFunction (Ptr ExternalFunction') where
+ marshal (ExternalFunction x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (ExternalFunction x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__ExternalFunction"
+ c_delete_casadi__ExternalFunction :: FunPtr (Ptr ExternalFunction' -> IO ())
+instance WrapReturn (Ptr ExternalFunction') ExternalFunction where
+ wrapReturn = (fmap ExternalFunction) . (newForeignPtr c_delete_casadi__ExternalFunction)
+
+
+-- raw decl
+data Function'
+-- data decl
+{-|
+>General function.
+>
+>A general function $f$ in casadi can be multi-input, multi-output. Number of
+>inputs: nin getNumInputs() Number of outputs: nout getNumOutputs() We can
+>view this function as a being composed of a ( nin, nout) grid of single-
+>input, single-output primitive functions. Each such primitive function $f_
+>{i, j} \\\\forall i \\\\in [0, nin-1], j \\\\in [0, nout-1]$ can map as
+>$\\\\mathbf {R}^{n, m}\\\\to\\\\mathbf{R}^{p, q}$, in which n, m, p, q can
+>take different values for every (i, j) pair. When passing input, you
+>specify which partition $i$ is active. You pass the numbers vectorized, as a
+>vector of size $(n*m)$. When requesting output, you specify which partition
+>$j$ is active. You get the numbers vectorized, as a vector of size $(p*q)$.
+>To calculate Jacobians, you need to have $(m=1, q=1)$.
+>
+>Write the Jacobian as $J_ {i, j} = \\\\nabla f_{i, j} = \\\\frac
+>{\\\\partial f_{i, j}(\\\\vec{x})}{\\\\partial \\\\vec{x}}$.
+>
+>Using $\\\\vec {v} \\\\in \\\\mathbf{R}^n$ as a forward seed: setFwdSeed(v,
+>i) Retrieving $\\\\vec {s}_f \\\\in \\\\mathbf{R}^p$ from: getFwdSens(sf, j)
+>Using $\\\\vec {w} \\\\in \\\\mathbf{R}^p$ as a forward seed: setAdjSeed(w,
+>j) Retrieving $\\\\vec {s}_a \\\\in \\\\mathbf{R}^n $ from: getAdjSens(sa,
+>i) We have the following relationships for function mapping from a row
+>vector to a row vector:
+>
+>$ \\\\vec {s}_f = \\\\nabla f_{i, j} . \\\\vec{v}$ $ \\\\vec {s}_a =
+>(\\\\nabla f_{i, j})^T . \\\\vec{w}$
+>
+>Some quantities in these formulas must be transposed: input col: transpose $
+>\\\\vec {v} $ and $\\\\vec{s}_a$ output col: transpose $ \\\\vec {w} $ and
+>$\\\\vec{s}_f$ NOTE: Functions are allowed to modify their input arguments
+>when evaluating: implicitFunction, IDAS solver Further releases may disallow
+>this.
+>
+>Joel Andersson
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>>List of available monitors
+>
+>+---------+--------------------------+
+>| Id | Used in |
+>+=========+==========================+
+>| inputs | casadi::FunctionInternal |
+>+---------+--------------------------+
+>| outputs | casadi::FunctionInternal |
+>+---------+--------------------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: function.hpp
+-}
+newtype Function = Function (ForeignPtr Function')
+-- typeclass decl
+class FunctionClass a where
+ castFunction :: a -> Function
+instance FunctionClass Function where
+ castFunction = id
+
+-- baseclass instances
+instance OptionsFunctionalityClass Function where
+ castOptionsFunctionality (Function x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass Function where
+ castSharedObject (Function x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass Function where
+ castIOInterfaceFunction (Function x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Function (Ptr Function') where
+ marshal (Function x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Function x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Function"
+ c_delete_casadi__Function :: FunPtr (Ptr Function' -> IO ())
+instance WrapReturn (Ptr Function') Function where
+ wrapReturn = (fmap Function) . (newForeignPtr c_delete_casadi__Function)
+
+
+-- raw decl
+data Functor'
+-- data decl
+{-|
+>Functor.
+>
+>Joris Gillis
+>
+>C++ includes: functor.hpp
+-}
+newtype Functor = Functor (ForeignPtr Functor')
+-- typeclass decl
+class FunctorClass a where
+ castFunctor :: a -> Functor
+instance FunctorClass Functor where
+ castFunctor = id
+
+-- baseclass instances
+instance SharedObjectClass Functor where
+ castSharedObject (Functor x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Functor (Ptr Functor') where
+ marshal (Functor x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Functor x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Functor"
+ c_delete_casadi__Functor :: FunPtr (Ptr Functor' -> IO ())
+instance WrapReturn (Ptr Functor') Functor where
+ wrapReturn = (fmap Functor) . (newForeignPtr c_delete_casadi__Functor)
+
+
+-- raw decl
+data GenericType'
+-- data decl
+{-|
+>Generic data type.
+>
+>Joel Andersson
+>
+>C++ includes: generic_type.hpp
+-}
+newtype GenericType = GenericType (ForeignPtr GenericType')
+-- typeclass decl
+class GenericTypeClass a where
+ castGenericType :: a -> GenericType
+instance GenericTypeClass GenericType where
+ castGenericType = id
+
+-- baseclass instances
+instance SharedObjectClass GenericType where
+ castSharedObject (GenericType x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal GenericType (Ptr GenericType') where
+ marshal (GenericType x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (GenericType x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__GenericType"
+ c_delete_casadi__GenericType :: FunPtr (Ptr GenericType' -> IO ())
+instance WrapReturn (Ptr GenericType') GenericType where
+ wrapReturn = (fmap GenericType) . (newForeignPtr c_delete_casadi__GenericType)
+
+
+-- raw decl
+data HomotopyNlpSolver'
+-- data decl
+{-|
+>Base class for Homotopy NLP Solvers.
+>
+>Solves the following parametric nonlinear program (NLP):
+>
+>::
+>
+> min F(x, p, tau)
+> x
+>
+> subject to
+> LBX <= x <= UBX
+> LBG <= G(x, p) <= UBG
+> p == P
+>
+> nx: number of decision variables
+> ng: number of constraints
+> np: number of parameters
+>
+>
+>
+>
+>In a homotopy from tau = 0 to tau = 1.
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::NlpSolverInput (NLP_SOLVER_NUM_IN = 8) [nlpSolverIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| NLP_SOLVER_X0 | x0 | Decision variables, |
+>| | | initial guess (nx x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_P | p | Value of fixed |
+>| | | parameters (np x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LBX | lbx | Decision variables |
+>| | | lower bound (nx x 1), |
+>| | | default -inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_UBX | ubx | Decision variables |
+>| | | upper bound (nx x 1), |
+>| | | default +inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LBG | lbg | Constraints lower |
+>| | | bound (ng x 1), |
+>| | | default -inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_UBG | ubg | Constraints upper |
+>| | | bound (ng x 1), |
+>| | | default +inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_X0 | lam_x0 | Lagrange multipliers |
+>| | | for bounds on X, |
+>| | | initial guess (nx x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_G0 | lam_g0 | Lagrange multipliers |
+>| | | for bounds on G, |
+>| | | initial guess (ng x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::NlpSolverOutput (NLP_SOLVER_NUM_OUT = 6) [nlpSolverOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| NLP_SOLVER_X | x | Decision variables at |
+>| | | the optimal solution |
+>| | | (nx x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_F | f | Cost function value at |
+>| | | the optimal solution |
+>| | | (1 x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_G | g | Constraints function |
+>| | | at the optimal |
+>| | | solution (ng x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_X | lam_x | Lagrange multipliers |
+>| | | for bounds on X at the |
+>| | | solution (nx x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_G | lam_g | Lagrange multipliers |
+>| | | for bounds on G at the |
+>| | | solution (ng x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_P | lam_p | Lagrange multipliers |
+>| | | for bounds on P at the |
+>| | | solution (np x 1) . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| expand | OT_BOOLEAN | false | Expand the | casadi::Homo |
+>| | | | NLP function | topyNLPInter |
+>| | | | in terms of | nal |
+>| | | | scalar | |
+>| | | | operations, | |
+>| | | | i.e. MX->SX | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- simple
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>HomotopyNlpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>simple
+>------
+>
+>
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| nlp_solver | OT_STRING | GenericType() | The NLP solver |
+>| | | | to be used by |
+>| | | | the Homotopy |
+>| | | | solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_solver_opti | OT_DICTIONARY | GenericType() | Options to be |
+>| ons | | | passed to the |
+>| | | | Homotopy solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| num_steps | OT_INTEGER | 10 | Take this many |
+>| | | | steps to go |
+>| | | | from tau=0 to |
+>| | | | tau=1. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: homotopy_nlp_solver.hpp
+-}
+newtype HomotopyNlpSolver = HomotopyNlpSolver (ForeignPtr HomotopyNlpSolver')
+-- typeclass decl
+class HomotopyNlpSolverClass a where
+ castHomotopyNlpSolver :: a -> HomotopyNlpSolver
+instance HomotopyNlpSolverClass HomotopyNlpSolver where
+ castHomotopyNlpSolver = id
+
+-- baseclass instances
+instance FunctionClass HomotopyNlpSolver where
+ castFunction (HomotopyNlpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass HomotopyNlpSolver where
+ castOptionsFunctionality (HomotopyNlpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass HomotopyNlpSolver where
+ castSharedObject (HomotopyNlpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass HomotopyNlpSolver where
+ castIOInterfaceFunction (HomotopyNlpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal HomotopyNlpSolver (Ptr HomotopyNlpSolver') where
+ marshal (HomotopyNlpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (HomotopyNlpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__HomotopyNlpSolver"
+ c_delete_casadi__HomotopyNlpSolver :: FunPtr (Ptr HomotopyNlpSolver' -> IO ())
+instance WrapReturn (Ptr HomotopyNlpSolver') HomotopyNlpSolver where
+ wrapReturn = (fmap HomotopyNlpSolver) . (newForeignPtr c_delete_casadi__HomotopyNlpSolver)
+
+
+-- raw decl
+data IMatrix'
+-- data decl
+{-|
+-}
+newtype IMatrix = IMatrix (ForeignPtr IMatrix')
+-- typeclass decl
+class IMatrixClass a where
+ castIMatrix :: a -> IMatrix
+instance IMatrixClass IMatrix where
+ castIMatrix = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal IMatrix (Ptr IMatrix') where
+ marshal (IMatrix x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (IMatrix x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__IMatrix"
+ c_delete_casadi__IMatrix :: FunPtr (Ptr IMatrix' -> IO ())
+instance WrapReturn (Ptr IMatrix') IMatrix where
+ wrapReturn = (fmap IMatrix) . (newForeignPtr c_delete_casadi__IMatrix)
+
+
+-- raw decl
+data IOScheme'
+-- data decl
+{-|
+>Class with mapping between names and indices.
+>
+>Joris Gillis
+>
+>C++ includes: io_scheme.hpp
+-}
+newtype IOScheme = IOScheme (ForeignPtr IOScheme')
+-- typeclass decl
+class IOSchemeClass a where
+ castIOScheme :: a -> IOScheme
+instance IOSchemeClass IOScheme where
+ castIOScheme = id
+
+-- baseclass instances
+instance SharedObjectClass IOScheme where
+ castSharedObject (IOScheme x) = SharedObject (castForeignPtr x)
+
+
+-- 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
+{-|
+>Abstract base class for the implicit function classes.
+>
+>The equation:
+>
+>F(z, x1, x2, ..., xn) == 0
+>
+>where d_F/dz is invertible, implicitly defines the equation:
+>
+>z := G(x1, x2, ..., xn)
+>
+>F should be an Function mapping from (n+1) inputs to m outputs. The first
+>output is the residual that should be zero.
+>
+>ImplicitFunction (G) is an Function mapping from n inputs to m outputs. n
+>may be zero. The first output is the solved for z.
+>
+>You can provide an initial guess for z by setting output(0) of
+>ImplicitFunction.
+>
+>General information
+>===================
+>
+>
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| constraints | OT_INTEGERVE | GenericType( | Constrain | casadi::Impl |
+>| | CTOR | ) | the | icitFunction |
+>| | | | unknowns. 0 | Internal |
+>| | | | (default): | |
+>| | | | no | |
+>| | | | constraint | |
+>| | | | on ui, 1: ui | |
+>| | | | >= 0.0, -1: | |
+>| | | | ui <= 0.0, | |
+>| | | | 2: ui > 0.0, | |
+>| | | | -2: ui < | |
+>| | | | 0.0. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| implicit_inp | OT_INTEGER | 0 | Index of the | casadi::Impl |
+>| ut | | | input that | icitFunction |
+>| | | | corresponds | Internal |
+>| | | | to the | |
+>| | | | actual root- | |
+>| | | | finding | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| implicit_out | OT_INTEGER | 0 | Index of the | casadi::Impl |
+>| put | | | output that | icitFunction |
+>| | | | corresponds | Internal |
+>| | | | to the | |
+>| | | | actual root- | |
+>| | | | finding | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| linear_solve | OT_STRING | GenericType( | User-defined | casadi::Impl |
+>| r | | ) | linear | icitFunction |
+>| | | | solver | Internal |
+>| | | | class. | |
+>| | | | Needed for s | |
+>| | | | ensitivities | |
+>| | | | . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| linear_solve | OT_DICTIONAR | GenericType( | Options to | casadi::Impl |
+>| r_options | Y | ) | be passed to | icitFunction |
+>| | | | the linear | Internal |
+>| | | | solver. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- kinsol
+>
+>- nlp
+>
+>- newton
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>ImplicitFunction.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>kinsol
+>------
+>
+>
+>
+>KINSOL interface from the Sundials suite
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| abstol | OT_REAL | 0.000 | Stopping |
+>| | | | criterion |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| disable_interna | OT_BOOLEAN | false | Disable KINSOL |
+>| l_warnings | | | internal |
+>| | | | warning |
+>| | | | messages |
+>+-----------------+-----------------+-----------------+-----------------+
+>| exact_jacobian | OT_BOOLEAN | true | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| f_scale | OT_REALVECTOR | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| iterative_solve | OT_STRING | "gmres" | gmres|bcgstab|t |
+>| r | | | fqmr |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_t | OT_STRING | "dense" | dense|banded|it |
+>| ype | | | erative|user_de |
+>| | | | fined |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lower_bandwidth | OT_INTEGER | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter | OT_INTEGER | 0 | Maximum number |
+>| | | | of Newton |
+>| | | | iterations. |
+>| | | | Putting 0 sets |
+>| | | | the default |
+>| | | | value of |
+>| | | | KinSol. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_krylov | OT_INTEGER | 0 | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pretype | OT_STRING | "none" | (none|left|righ |
+>| | | | t|both) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| strategy | OT_STRING | "none" | Globalization |
+>| | | | strategy (none| |
+>| | | | linesearch) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| u_scale | OT_REALVECTOR | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| upper_bandwidth | OT_INTEGER | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| use_preconditio | OT_BOOLEAN | false | precondition an |
+>| ner | | | iterative |
+>| | | | solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-----------+
+>| Id |
+>+===========+
+>| eval_djac |
+>+-----------+
+>| eval_f |
+>+-----------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>nlp
+>---
+>
+>
+>
+>Use an NlpSolver as ImplicitFunction solver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>>List of available stats
+>
+>+--------------+
+>| Id |
+>+==============+
+>| solver_stats |
+>+--------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>newton
+>------
+>
+>
+>
+>Implements simple newton iterations to solve an implicit function.
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| abstol | OT_REAL | 0.000 | Stopping |
+>| | | | criterion |
+>| | | | tolerance on |
+>| | | | max(|F|) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| abstolStep | OT_REAL | 0.000 | Stopping |
+>| | | | criterion |
+>| | | | tolerance on |
+>| | | | step size |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter | OT_INTEGER | 1000 | Maximum number |
+>| | | | of Newton |
+>| | | | iterations to |
+>| | | | perform before |
+>| | | | returning. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_iteration | OT_BOOLEAN | false | Print |
+>| | | | information |
+>| | | | about each |
+>| | | | iteration |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+----------+
+>| Id |
+>+==========+
+>| F |
+>+----------+
+>| J |
+>+----------+
+>| normF |
+>+----------+
+>| step |
+>+----------+
+>| stepsize |
+>+----------+
+>
+>>List of available stats
+>
+>+---------------+
+>| Id |
+>+===============+
+>| iter |
+>+---------------+
+>| return_status |
+>+---------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: implicit_function.hpp
+-}
+newtype ImplicitFunction = ImplicitFunction (ForeignPtr ImplicitFunction')
+-- typeclass decl
+class ImplicitFunctionClass a where
+ castImplicitFunction :: a -> ImplicitFunction
+instance ImplicitFunctionClass ImplicitFunction where
+ castImplicitFunction = id
+
+-- baseclass instances
+instance FunctionClass ImplicitFunction where
+ castFunction (ImplicitFunction x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass ImplicitFunction where
+ castOptionsFunctionality (ImplicitFunction x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass ImplicitFunction where
+ castSharedObject (ImplicitFunction x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass ImplicitFunction where
+ castIOInterfaceFunction (ImplicitFunction x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal ImplicitFunction (Ptr ImplicitFunction') where
+ marshal (ImplicitFunction x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (ImplicitFunction x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__ImplicitFunction"
+ c_delete_casadi__ImplicitFunction :: FunPtr (Ptr ImplicitFunction' -> IO ())
+instance WrapReturn (Ptr ImplicitFunction') ImplicitFunction where
+ wrapReturn = (fmap ImplicitFunction) . (newForeignPtr c_delete_casadi__ImplicitFunction)
+
+
+-- raw decl
+data Integrator'
+-- data decl
+{-|
+>Base class for integrators.
+>
+>Integrator abstract base class
+>
+>Solves an initial value problem (IVP) coupled to a terminal value problem
+>with differential equation given as an implicit ODE coupled to an algebraic
+>equation and a set of quadratures:
+>
+>::
+>
+> Initial conditions at t=t0
+> x(t0) = x0
+> q(t0) = 0
+>
+> Forward integration from t=t0 to t=tf
+> der(x) = function(x, z, p, t) Forward ODE
+> 0 = fz(x, z, p, t) Forward algebraic equations
+> der(q) = fq(x, z, p, t) Forward quadratures
+>
+> Terminal conditions at t=tf
+> rx(tf) = rx0
+> rq(tf) = 0
+>
+> Backward integration from t=tf to t=t0
+> der(rx) = gx(rx, rz, rp, x, z, p, t) Backward ODE
+> 0 = gz(rx, rz, rp, x, z, p, t) Backward algebraic equations
+> der(rq) = gq(rx, rz, rp, x, z, p, t) Backward quadratures
+>
+> where we assume that both the forward and backwards integrations are index-1
+> (i.e. dfz/dz, dgz/drz are invertible) and furthermore that
+> gx, gz and gq have a linear dependency on rx, rz and rp.
+>
+>
+>
+>The Integrator class provides some additional functionality, such as getting
+>the value of the state and/or sensitivities at certain time points.
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::IntegratorInput (INTEGRATOR_NUM_IN = 6) [integratorIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| INTEGRATOR_X0 | x0 | Differential state at |
+>| | | the initial time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_P | p | Parameters . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_Z0 | z0 | Initial guess for the |
+>| | | algebraic variable . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RX0 | rx0 | Backward differential |
+>| | | state at the final |
+>| | | time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RP | rp | Backward parameter |
+>| | | vector . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RZ0 | rz0 | Initial guess for the |
+>| | | backwards algebraic |
+>| | | variable . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::IntegratorOutput (INTEGRATOR_NUM_OUT = 6) [integratorOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| INTEGRATOR_XF | xf | Differential state at |
+>| | | the final time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_QF | qf | Quadrature state at |
+>| | | the final time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_ZF | zf | Algebraic variable at |
+>| | | the final time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RXF | rxf | Backward differential |
+>| | | state at the initial |
+>| | | time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RQF | rqf | Backward quadrature |
+>| | | state at the initial |
+>| | | time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RZF | rzf | Backward algebraic |
+>| | | variable at the |
+>| | | initial time . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| augmented_op | OT_DICTIONAR | GenericType( | Options to | casadi::Inte |
+>| tions | Y | ) | be passed | gratorIntern |
+>| | | | down to the | al |
+>| | | | augmented | |
+>| | | | integrator, | |
+>| | | | if one is | |
+>| | | | constructed. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| expand_augme | OT_BOOLEAN | true | If DAE | casadi::Inte |
+>| nted | | | callback | gratorIntern |
+>| | | | functions | al |
+>| | | | are | |
+>| | | | SXFunction , | |
+>| | | | have | |
+>| | | | augmented | |
+>| | | | DAE callback | |
+>| | | | function | |
+>| | | | also be | |
+>| | | | SXFunction . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| print_stats | OT_BOOLEAN | false | Print out | casadi::Inte |
+>| | | | statistics | gratorIntern |
+>| | | | after | al |
+>| | | | integration | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| t0 | OT_REAL | 0 | Beginning of | casadi::Inte |
+>| | | | the time | gratorIntern |
+>| | | | horizon | al |
+>+--------------+--------------+--------------+--------------+--------------+
+>| tf | OT_REAL | 1 | End of the | casadi::Inte |
+>| | | | time horizon | gratorIntern |
+>| | | | | al |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- cvodes
+>
+>- idas
+>
+>- collocation
+>
+>- oldcollocation
+>
+>- rk
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>Integrator.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>cvodes
+>------
+>
+>
+>
+>Interface to CVodes from the Sundials suite.
+>
+>A call to evaluate will integrate to the end.
+>
+>You can retrieve the entire state trajectory as follows, after the evaluate
+>call: Call reset. Then call integrate(t_i) and getOuput for a series of
+>times t_i.
+>
+>Note: depending on the dimension and structure of your problem, you may
+>experience a dramatic speed-up by using a sparse linear solver:
+>
+>
+>
+>::
+>
+> intg.setOption("linear_solver","csparse")
+> intg.setOption("linear_solver_type","user_defined")
+>
+>
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| abstol | OT_REAL | 0.000 | Absolute |
+>| | | | tolerence for |
+>| | | | the IVP |
+>| | | | solution |
+>+-----------------+-----------------+-----------------+-----------------+
+>| abstolB | OT_REAL | GenericType() | Absolute |
+>| | | | tolerence for |
+>| | | | the adjoint |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to abstol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| disable_interna | OT_BOOLEAN | false | Disable CVodes |
+>| l_warnings | | | internal |
+>| | | | warning |
+>| | | | messages |
+>+-----------------+-----------------+-----------------+-----------------+
+>| exact_jacobian | OT_BOOLEAN | true | Use exact |
+>| | | | Jacobian |
+>| | | | information for |
+>| | | | the forward |
+>| | | | integration |
+>+-----------------+-----------------+-----------------+-----------------+
+>| exact_jacobianB | OT_BOOLEAN | GenericType() | Use exact |
+>| | | | Jacobian |
+>| | | | information for |
+>| | | | the backward |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to |
+>| | | | exact_jacobian] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| finite_differen | OT_BOOLEAN | false | Use finite |
+>| ce_fsens | | | differences to |
+>| | | | approximate the |
+>| | | | forward |
+>| | | | sensitivity |
+>| | | | equations (if |
+>| | | | AD is not |
+>| | | | available) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_abstol | OT_REAL | GenericType() | Absolute |
+>| | | | tolerence for |
+>| | | | the forward |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to abstol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_all_at_on | OT_BOOLEAN | true | Calculate all |
+>| ce | | | right hand |
+>| | | | sides of the |
+>| | | | sensitivity |
+>| | | | equations at |
+>| | | | once |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_err_con | OT_BOOLEAN | true | include the |
+>| | | | forward |
+>| | | | sensitivities |
+>| | | | in all error |
+>| | | | controls |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_reltol | OT_REAL | GenericType() | Relative |
+>| | | | tolerence for |
+>| | | | the forward |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to reltol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_scaling_f | OT_REALVECTOR | GenericType() | Scaling factor |
+>| actors | | | for the |
+>| | | | components if |
+>| | | | finite |
+>| | | | differences is |
+>| | | | used |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_sensitivi | OT_INTEGERVECTO | GenericType() | Specifies which |
+>| y_parameters | R | | components will |
+>| | | | be used when |
+>| | | | estimating the |
+>| | | | sensitivity |
+>| | | | equations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| interpolation_t | OT_STRING | "hermite" | Type of |
+>| ype | | | interpolation |
+>| | | | for the adjoint |
+>| | | | sensitivities ( |
+>| | | | hermite|polynom |
+>| | | | ial) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| iterative_solve | OT_STRING | "gmres" | (gmres|bcgstab| |
+>| r | | | tfqmr) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| iterative_solve | OT_STRING | GenericType() | (gmres|bcgstab| |
+>| rB | | | tfqmr) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_multiste | OT_STRING | "bdf" | Integrator |
+>| p_method | | | scheme |
+>| | | | (bdf|adams) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver | OT_STRING | GenericType() | A custom linear |
+>| | | | solver creator |
+>| | | | function |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solverB | OT_STRING | GenericType() | A custom linear |
+>| | | | solver creator |
+>| | | | function for |
+>| | | | backwards |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to |
+>| | | | linear_solver] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptions | | | passed to the |
+>| | | | linear solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptionsB | | | passed to the |
+>| | | | linear solver |
+>| | | | for backwards |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to linear_solve |
+>| | | | r_options] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_t | OT_STRING | "dense" | (user_defined|d |
+>| ype | | | ense|banded|ite |
+>| | | | rative) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_t | OT_STRING | GenericType() | (user_defined|d |
+>| ypeB | | | ense|banded|ite |
+>| | | | rative) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lower_bandwidth | OT_INTEGER | GenericType() | Lower band- |
+>| | | | width of banded |
+>| | | | Jacobian |
+>| | | | (estimations) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lower_bandwidth | OT_INTEGER | GenericType() | lower band- |
+>| B | | | width of banded |
+>| | | | jacobians for |
+>| | | | backward |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to lower_bandwi |
+>| | | | dth] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_krylov | OT_INTEGER | 10 | Maximum Krylov |
+>| | | | subspace size |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_krylovB | OT_INTEGER | GenericType() | Maximum krylov |
+>| | | | subspace size |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_multistep_o | OT_INTEGER | 5 | |
+>| rder | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_num_steps | OT_INTEGER | 10000 | Maximum number |
+>| | | | of integrator |
+>| | | | steps |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nonlinear_solve | OT_STRING | "newton" | (newton|functio |
+>| r_iteration | | | nal) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pretype | OT_STRING | "none" | (none|left|righ |
+>| | | | t|both) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pretypeB | OT_STRING | GenericType() | (none|left|righ |
+>| | | | t|both) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quad_err_con | OT_BOOLEAN | false | Should the |
+>| | | | quadratures |
+>| | | | affect the step |
+>| | | | size control |
+>+-----------------+-----------------+-----------------+-----------------+
+>| reltol | OT_REAL | 0.000 | Relative |
+>| | | | tolerence for |
+>| | | | the IVP |
+>| | | | solution |
+>+-----------------+-----------------+-----------------+-----------------+
+>| reltolB | OT_REAL | GenericType() | Relative |
+>| | | | tolerence for |
+>| | | | the adjoint |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to reltol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| sensitivity_met | OT_STRING | "simultaneous" | (simultaneous|s |
+>| hod | | | taggered) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| steps_per_check | OT_INTEGER | 20 | Number of steps |
+>| point | | | between two |
+>| | | | consecutive |
+>| | | | checkpoints |
+>+-----------------+-----------------+-----------------+-----------------+
+>| stop_at_end | OT_BOOLEAN | true | Stop the |
+>| | | | integrator at |
+>| | | | the end of the |
+>| | | | interval |
+>+-----------------+-----------------+-----------------+-----------------+
+>| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
+>| | | | width of banded |
+>| | | | Jacobian |
+>| | | | (estimations) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
+>| B | | | width of banded |
+>| | | | jacobians for |
+>| | | | backward |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to upper_bandwi |
+>| | | | dth] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| use_preconditio | OT_BOOLEAN | false | Precondition an |
+>| ner | | | iterative |
+>| | | | solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| use_preconditio | OT_BOOLEAN | GenericType() | Precondition an |
+>| nerB | | | iterative |
+>| | | | solver for the |
+>| | | | backwards |
+>| | | | problem |
+>| | | | [default: equal |
+>| | | | to use_precondi |
+>| | | | tioner] |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+---------+
+>| Id |
+>+=========+
+>| djacB |
+>+---------+
+>| psetupB |
+>+---------+
+>| res |
+>+---------+
+>| resB |
+>+---------+
+>| resQB |
+>+---------+
+>| reset |
+>+---------+
+>
+>>List of available stats
+>
+>+-------------+
+>| Id |
+>+=============+
+>| nlinsetups |
+>+-------------+
+>| nlinsetupsB |
+>+-------------+
+>| nsteps |
+>+-------------+
+>| nstepsB |
+>+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>idas
+>----
+>
+>
+>
+>Interface to IDAS from the Sundials suite.
+>
+>Note: depending on the dimension and structure of your problem, you may
+>experience a dramatic speed-up by using a sparse linear solver:
+>
+>
+>
+>::
+>
+> intg.setOption("linear_solver","csparse")
+> intg.setOption("linear_solver_type","user_defined")
+>
+>
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| abstol | OT_REAL | 0.000 | Absolute |
+>| | | | tolerence for |
+>| | | | the IVP |
+>| | | | solution |
+>+-----------------+-----------------+-----------------+-----------------+
+>| abstolB | OT_REAL | GenericType() | Absolute |
+>| | | | tolerence for |
+>| | | | the adjoint |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to abstol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| abstolv | OT_REALVECTOR | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| calc_ic | OT_BOOLEAN | true | Use IDACalcIC |
+>| | | | to get |
+>| | | | consistent |
+>| | | | initial |
+>| | | | conditions. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| calc_icB | OT_BOOLEAN | GenericType() | Use IDACalcIC |
+>| | | | to get |
+>| | | | consistent |
+>| | | | initial |
+>| | | | conditions for |
+>| | | | backwards |
+>| | | | system |
+>| | | | [default: equal |
+>| | | | to calc_ic]. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| cj_scaling | OT_BOOLEAN | false | IDAS scaling on |
+>| | | | cj for the |
+>| | | | user-defined |
+>| | | | linear solver |
+>| | | | module |
+>+-----------------+-----------------+-----------------+-----------------+
+>| disable_interna | OT_BOOLEAN | false | Disable IDAS |
+>| l_warnings | | | internal |
+>| | | | warning |
+>| | | | messages |
+>+-----------------+-----------------+-----------------+-----------------+
+>| exact_jacobian | OT_BOOLEAN | true | Use exact |
+>| | | | Jacobian |
+>| | | | information for |
+>| | | | the forward |
+>| | | | integration |
+>+-----------------+-----------------+-----------------+-----------------+
+>| exact_jacobianB | OT_BOOLEAN | GenericType() | Use exact |
+>| | | | Jacobian |
+>| | | | information for |
+>| | | | the backward |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to |
+>| | | | exact_jacobian] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| extra_fsens_cal | OT_BOOLEAN | false | Call calc ic an |
+>| c_ic | | | extra time, |
+>| | | | with fsens=0 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| finite_differen | OT_BOOLEAN | false | Use finite |
+>| ce_fsens | | | differences to |
+>| | | | approximate the |
+>| | | | forward |
+>| | | | sensitivity |
+>| | | | equations (if |
+>| | | | AD is not |
+>| | | | available) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| first_time | OT_REAL | GenericType() | First requested |
+>| | | | time as a |
+>| | | | fraction of the |
+>| | | | time interval |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_abstol | OT_REAL | GenericType() | Absolute |
+>| | | | tolerence for |
+>| | | | the forward |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to abstol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_abstolv | OT_REALVECTOR | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_err_con | OT_BOOLEAN | true | include the |
+>| | | | forward |
+>| | | | sensitivities |
+>| | | | in all error |
+>| | | | controls |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_reltol | OT_REAL | GenericType() | Relative |
+>| | | | tolerence for |
+>| | | | the forward |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to reltol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_scaling_f | OT_REALVECTOR | GenericType() | Scaling factor |
+>| actors | | | for the |
+>| | | | components if |
+>| | | | finite |
+>| | | | differences is |
+>| | | | used |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fsens_sensitivi | OT_INTEGERVECTO | GenericType() | Specifies which |
+>| y_parameters | R | | components will |
+>| | | | be used when |
+>| | | | estimating the |
+>| | | | sensitivity |
+>| | | | equations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| init_xdot | OT_REALVECTOR | GenericType() | Initial values |
+>| | | | for the state |
+>| | | | derivatives |
+>+-----------------+-----------------+-----------------+-----------------+
+>| interpolation_t | OT_STRING | "hermite" | Type of |
+>| ype | | | interpolation |
+>| | | | for the adjoint |
+>| | | | sensitivities ( |
+>| | | | hermite|polynom |
+>| | | | ial) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| iterative_solve | OT_STRING | "gmres" | (gmres|bcgstab| |
+>| r | | | tfqmr) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| iterative_solve | OT_STRING | GenericType() | (gmres|bcgstab| |
+>| rB | | | tfqmr) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver | OT_STRING | GenericType() | A custom linear |
+>| | | | solver creator |
+>| | | | function |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solverB | OT_STRING | GenericType() | A custom linear |
+>| | | | solver creator |
+>| | | | function for |
+>| | | | backwards |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to |
+>| | | | linear_solver] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptions | | | passed to the |
+>| | | | linear solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_o | OT_DICTIONARY | GenericType() | Options to be |
+>| ptionsB | | | passed to the |
+>| | | | linear solver |
+>| | | | for backwards |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to linear_solve |
+>| | | | r_options] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_t | OT_STRING | "dense" | (user_defined|d |
+>| ype | | | ense|banded|ite |
+>| | | | rative) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver_t | OT_STRING | GenericType() | (user_defined|d |
+>| ypeB | | | ense|banded|ite |
+>| | | | rative) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lower_bandwidth | OT_INTEGER | GenericType() | Lower band- |
+>| | | | width of banded |
+>| | | | Jacobian |
+>| | | | (estimations) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lower_bandwidth | OT_INTEGER | GenericType() | lower band- |
+>| B | | | width of banded |
+>| | | | jacobians for |
+>| | | | backward |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to lower_bandwi |
+>| | | | dth] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_krylov | OT_INTEGER | 10 | Maximum Krylov |
+>| | | | subspace size |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_krylovB | OT_INTEGER | GenericType() | Maximum krylov |
+>| | | | subspace size |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_multistep_o | OT_INTEGER | 5 | |
+>| rder | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_num_steps | OT_INTEGER | 10000 | Maximum number |
+>| | | | of integrator |
+>| | | | steps |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_step_size | OT_REAL | 0 | Maximim step |
+>| | | | size |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pretype | OT_STRING | "none" | (none|left|righ |
+>| | | | t|both) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pretypeB | OT_STRING | GenericType() | (none|left|righ |
+>| | | | t|both) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quad_err_con | OT_BOOLEAN | false | Should the |
+>| | | | quadratures |
+>| | | | affect the step |
+>| | | | size control |
+>+-----------------+-----------------+-----------------+-----------------+
+>| reltol | OT_REAL | 0.000 | Relative |
+>| | | | tolerence for |
+>| | | | the IVP |
+>| | | | solution |
+>+-----------------+-----------------+-----------------+-----------------+
+>| reltolB | OT_REAL | GenericType() | Relative |
+>| | | | tolerence for |
+>| | | | the adjoint |
+>| | | | sensitivity |
+>| | | | solution |
+>| | | | [default: equal |
+>| | | | to reltol] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| sensitivity_met | OT_STRING | "simultaneous" | (simultaneous|s |
+>| hod | | | taggered) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| steps_per_check | OT_INTEGER | 20 | Number of steps |
+>| point | | | between two |
+>| | | | consecutive |
+>| | | | checkpoints |
+>+-----------------+-----------------+-----------------+-----------------+
+>| stop_at_end | OT_BOOLEAN | true | Stop the |
+>| | | | integrator at |
+>| | | | the end of the |
+>| | | | interval |
+>+-----------------+-----------------+-----------------+-----------------+
+>| suppress_algebr | OT_BOOLEAN | false | Suppress |
+>| aic | | | algebraic |
+>| | | | variables in |
+>| | | | the error |
+>| | | | testing |
+>+-----------------+-----------------+-----------------+-----------------+
+>| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
+>| | | | width of banded |
+>| | | | Jacobian |
+>| | | | (estimations) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| upper_bandwidth | OT_INTEGER | GenericType() | Upper band- |
+>| B | | | width of banded |
+>| | | | jacobians for |
+>| | | | backward |
+>| | | | integration |
+>| | | | [default: equal |
+>| | | | to upper_bandwi |
+>| | | | dth] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| use_preconditio | OT_BOOLEAN | false | Precondition an |
+>| ner | | | iterative |
+>| | | | solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| use_preconditio | OT_BOOLEAN | GenericType() | Precondition an |
+>| nerB | | | iterative |
+>| | | | solver for the |
+>| | | | backwards |
+>| | | | problem |
+>| | | | [default: equal |
+>| | | | to use_precondi |
+>| | | | tioner] |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+--------------------------+
+>| Id |
+>+==========================+
+>| bjacB |
+>+--------------------------+
+>| correctInitialConditions |
+>+--------------------------+
+>| jtimesB |
+>+--------------------------+
+>| psetup |
+>+--------------------------+
+>| psetupB |
+>+--------------------------+
+>| psolveB |
+>+--------------------------+
+>| res |
+>+--------------------------+
+>| resB |
+>+--------------------------+
+>| resS |
+>+--------------------------+
+>| rhsQB |
+>+--------------------------+
+>
+>>List of available stats
+>
+>+-------------+
+>| Id |
+>+=============+
+>| nlinsetups |
+>+-------------+
+>| nlinsetupsB |
+>+-------------+
+>| nsteps |
+>+-------------+
+>| nstepsB |
+>+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>collocation
+>-----------
+>
+>
+>
+>Fixed-step implicit Runge-Kutta integrator ODE/DAE integrator based on
+>collocation schemes
+>
+>The method is still under development
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| collocation_sch | OT_STRING | "radau" | Collocation |
+>| eme | | | scheme (radau|l |
+>| | | | egendre) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| implicit_solver | OT_STRING | GenericType() | An implicit |
+>| | | | function solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| implicit_solver | OT_DICTIONARY | GenericType() | Options to be |
+>| _options | | | passed to the |
+>| | | | NLP Solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| interpolation_o | OT_INTEGER | 3 | Order of the |
+>| rder | | | interpolating |
+>| | | | polynomials |
+>+-----------------+-----------------+-----------------+-----------------+
+>| number_of_finit | OT_INTEGER | 20 | Number of |
+>| e_elements | | | finite elements |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>oldcollocation
+>--------------
+>
+>
+>
+>Collocation integrator ODE/DAE integrator based on collocation
+>
+>The method is still under development
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| collocation_sch | OT_STRING | "radau" | Collocation |
+>| eme | | | scheme (radau|l |
+>| | | | egendre) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| expand_f | OT_BOOLEAN | false | Expand the |
+>| | | | ODE/DAE |
+>| | | | residual |
+>| | | | function in an |
+>| | | | SX graph |
+>+-----------------+-----------------+-----------------+-----------------+
+>| expand_q | OT_BOOLEAN | false | Expand the |
+>| | | | quadrature |
+>| | | | function in an |
+>| | | | SX graph |
+>+-----------------+-----------------+-----------------+-----------------+
+>| hotstart | OT_BOOLEAN | true | Initialize the |
+>| | | | trajectory at |
+>| | | | the previous |
+>| | | | solution |
+>+-----------------+-----------------+-----------------+-----------------+
+>| implicit_solver | OT_STRING | GenericType() | An implicit |
+>| | | | function solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| implicit_solver | OT_DICTIONARY | GenericType() | Options to be |
+>| _options | | | passed to the |
+>| | | | implicit solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| interpolation_o | OT_INTEGER | 3 | Order of the |
+>| rder | | | interpolating |
+>| | | | polynomials |
+>+-----------------+-----------------+-----------------+-----------------+
+>| number_of_finit | OT_INTEGER | 20 | Number of |
+>| e_elements | | | finite elements |
+>+-----------------+-----------------+-----------------+-----------------+
+>| startup_integra | OT_STRING | GenericType() | An ODE/DAE |
+>| tor | | | integrator that |
+>| | | | can be used to |
+>| | | | generate a |
+>| | | | startup |
+>| | | | trajectory |
+>+-----------------+-----------------+-----------------+-----------------+
+>| startup_integra | OT_DICTIONARY | GenericType() | Options to be |
+>| tor_options | | | passed to the |
+>| | | | startup |
+>| | | | integrator |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>rk --
+>
+>
+>
+>Fixed-step explicit Runge-Kutta integrator for ODEs Currently implements
+>RK4.
+>
+>The method is still under development
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| number_of_finit | OT_INTEGER | 20 | Number of |
+>| e_elements | | | finite elements |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: integrator.hpp
+-}
+newtype Integrator = Integrator (ForeignPtr Integrator')
+-- typeclass decl
+class IntegratorClass a where
+ castIntegrator :: a -> Integrator
+instance IntegratorClass Integrator where
+ castIntegrator = id
+
+-- baseclass instances
+instance FunctionClass Integrator where
+ castFunction (Integrator x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass Integrator where
+ castOptionsFunctionality (Integrator x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass Integrator where
+ castSharedObject (Integrator x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass Integrator where
+ castIOInterfaceFunction (Integrator x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Integrator (Ptr Integrator') where
+ marshal (Integrator x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Integrator x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Integrator"
+ c_delete_casadi__Integrator :: FunPtr (Ptr Integrator' -> IO ())
+instance WrapReturn (Ptr Integrator') Integrator where
+ wrapReturn = (fmap Integrator) . (newForeignPtr c_delete_casadi__Integrator)
+
+
+-- raw decl
+data LinearSolver'
+-- data decl
+{-|
+>Base class for the linear solver classes.
+>
+>Solves the linear system A*X = B or A^T*X = B for X with A square and non-
+>singular
+>
+>If A is structurally singular, an error will be thrown during init. If A is
+>numerically singular, the prepare step will fail.
+>
+>The usual procedure to use LinearSolver is: init()
+>
+>set the first input (A)
+>
+>prepare()
+>
+>set the second input (b)
+>
+>solve()
+>
+>Repeat steps 4 and 5 to work with other b vectors.
+>
+>The method evaluate() combines the prepare() and solve() step and is
+>therefore more expensive if A is invariant.
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::LinsolInput (LINSOL_NUM_IN = 2) [linsolIn]
+>
+>+-----------+-------+------------------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+================================================+
+>| LINSOL_A | A | The square matrix A: sparse, (n x n). . |
+>+-----------+-------+------------------------------------------------+
+>| LINSOL_B | B | The right-hand-side matrix b: dense, (n x m) . |
+>+-----------+-------+------------------------------------------------+
+>
+>>Output scheme: casadi::LinsolOutput (LINSOL_NUM_OUT = 1) [linsolOut]
+>
+>+-----------+-------+----------------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+==============================================+
+>| LINSOL_X | X | Solution to the linear system of equations . |
+>+-----------+-------+----------------------------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- csparsecholesky
+>
+>- csparse
+>
+>- lapacklu
+>
+>- lapackqr
+>
+>- symbolicqr
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>LinearSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>csparsecholesky
+>---------------
+>
+>
+>
+>LinearSolver with CSparseCholesky Interface
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>csparse
+>-------
+>
+>
+>
+>LinearSolver with CSparse Interface
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>lapacklu
+>--------
+>
+>
+>
+>This class solves the linear system A.x=b by making an LU factorization of
+>A: A = L.U, with L lower and U upper triangular
+>
+>>List of available options
+>
+>+-----------------------------+------------+---------+-------------+
+>| Id | Type | Default | Description |
+>+=============================+============+=========+=============+
+>| allow_equilibration_failure | OT_BOOLEAN | false | |
+>+-----------------------------+------------+---------+-------------+
+>| equilibration | OT_BOOLEAN | true | |
+>+-----------------------------+------------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>lapackqr
+>--------
+>
+>
+>
+>This class solves the linear system A.x=b by making an QR factorization of
+>A: A = Q.R, with Q orthogonal and R upper triangular
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>symbolicqr
+>----------
+>
+>
+>
+>LinearSolver based on QR factorization with sparsity pattern based
+>reordering without partial pivoting
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| codegen | OT_BOOLEAN | false | C-code |
+>| | | | generation |
+>+-----------------+-----------------+-----------------+-----------------+
+>| compiler | OT_STRING | "gcc -fPIC -O2" | Compiler |
+>| | | | command to be |
+>| | | | used for |
+>| | | | compiling |
+>| | | | generated code |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: linear_solver.hpp
+-}
+newtype LinearSolver = LinearSolver (ForeignPtr LinearSolver')
+-- typeclass decl
+class LinearSolverClass a where
+ castLinearSolver :: a -> LinearSolver
+instance LinearSolverClass LinearSolver where
+ castLinearSolver = id
+
+-- baseclass instances
+instance FunctionClass LinearSolver where
+ castFunction (LinearSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass LinearSolver where
+ castOptionsFunctionality (LinearSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass LinearSolver where
+ castSharedObject (LinearSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass LinearSolver where
+ castIOInterfaceFunction (LinearSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal LinearSolver (Ptr LinearSolver') where
+ marshal (LinearSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (LinearSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__LinearSolver"
+ c_delete_casadi__LinearSolver :: FunPtr (Ptr LinearSolver' -> IO ())
+instance WrapReturn (Ptr LinearSolver') LinearSolver where
+ wrapReturn = (fmap LinearSolver) . (newForeignPtr c_delete_casadi__LinearSolver)
+
+
+-- raw decl
+data LpSolver'
+-- data decl
+{-|
+>LpSolver.
+>
+>Solves the following linear problem:
+>
+>
+>
+>::
+>
+> min c' x
+> x
+>
+> subject to
+> LBA <= A x <= UBA
+> LBX <= x <= UBX
+>
+> with x ( n x 1)
+> c ( n x 1 )
+> A sparse matrix ( nc x n)
+> LBA, UBA dense vector (nc x 1)
+> LBX, UBX dense vector (n x 1)
+>
+> n: number of decision variables (x)
+> nc: number of constraints (A)
+>
+>
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::LpSolverInput (LP_SOLVER_NUM_IN = 6) [lpIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| LP_SOLVER_C | c | The vector c: dense (n |
+>| | | x 1) . |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_A | a | The matrix A: sparse, |
+>| | | (nc x n) - product |
+>| | | with x must be dense. |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_LBA | lba | dense, (nc x 1) |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_UBA | uba | dense, (nc x 1) |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_LBX | lbx | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_UBX | ubx | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::LpSolverOutput (LP_SOLVER_NUM_OUT = 4) [lpOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| LP_SOLVER_X | x | The primal solution . |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_COST | cost | The optimal cost . |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_LAM_A | lam_a | The dual solution |
+>| | | corresponding to |
+>| | | linear bounds . |
+>+------------------------+------------------------+------------------------+
+>| LP_SOLVER_LAM_X | lam_x | The dual solution |
+>| | | corresponding to |
+>| | | simple bounds . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- qp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>LpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>qp --
+>
+>
+>
+>Solve LPs using a QpSolver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>>List of available stats
+>
+>+-----------------+
+>| Id |
+>+=================+
+>| qp_solver_stats |
+>+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: lp_solver.hpp
+-}
+newtype LpSolver = LpSolver (ForeignPtr LpSolver')
+-- typeclass decl
+class LpSolverClass a where
+ castLpSolver :: a -> LpSolver
+instance LpSolverClass LpSolver where
+ castLpSolver = id
+
+-- baseclass instances
+instance FunctionClass LpSolver where
+ castFunction (LpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass LpSolver where
+ castOptionsFunctionality (LpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass LpSolver where
+ castSharedObject (LpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass LpSolver where
+ castIOInterfaceFunction (LpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal LpSolver (Ptr LpSolver') where
+ marshal (LpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (LpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__LpSolver"
+ c_delete_casadi__LpSolver :: FunPtr (Ptr LpSolver' -> IO ())
+instance WrapReturn (Ptr LpSolver') LpSolver where
+ wrapReturn = (fmap LpSolver) . (newForeignPtr c_delete_casadi__LpSolver)
+
+
+-- raw decl
+data LrDleSolver'
+-- data decl
+{-|
+>Base class for Low-rank Discrete Lyapunov Equation Solvers.
+>
+>
+>
+>::
+>
+> A in R^(n x n)
+> V in S^m
+> C in R^(n x m)
+> Hi in R^(n x Hsi)
+>
+>
+>
+>
+>finds $P$ that satisfies:
+>
+>
+>
+>::
+>
+> P = A P A' + C V C'
+>
+>
+>
+>
+>and outputs
+>
+>Yi = Hi^T P Hi
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::LR_DLEInput (LR_DLE_NUM_IN = 4) [lrdleIn]
+>
+>+-----------+-------+----------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+========================================+
+>| LR_DLE_A | a | A matrix . |
+>+-----------+-------+----------------------------------------+
+>| LR_DLE_V | v | V matrix . |
+>+-----------+-------+----------------------------------------+
+>| LR_DLE_C | c | C matrix . |
+>+-----------+-------+----------------------------------------+
+>| LR_DLE_H | h | H matrix: horizontal stack of all Hi . |
+>+-----------+-------+----------------------------------------+
+>
+>>Output scheme: casadi::LR_DLEOutput (LR_DLE_NUM_OUT = 1) [lrdleOut]
+>
+>+-----------+-------+--------------------------+
+>| Full name | Short | Description |
+>+===========+=======+==========================+
+>| LR_DLE_Y | y | Y matrix, blkdiag form . |
+>+-----------+-------+--------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| eps_unstable | OT_REAL | 0.000 | A margin for | casadi::LrDl |
+>| | | | unstability | eInternal |
+>| | | | detection | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| error_unstab | OT_BOOLEAN | false | Throw an | casadi::LrDl |
+>| le | | | exception | eInternal |
+>| | | | when it is | |
+>| | | | detected | |
+>| | | | that | |
+>| | | | Product(A_i, | |
+>| | | | i=N..1) has | |
+>| | | | eigenvalues | |
+>| | | | greater than | |
+>| | | | 1-eps_unstab | |
+>| | | | le | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| pos_def | OT_BOOLEAN | false | Assume P | casadi::LrDl |
+>| | | | positive | eInternal |
+>| | | | definite | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- dle
+>
+>- fixed_smith
+>
+>- smith
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>LrDleSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>dle
+>---
+>
+>
+>
+>Solving the Low-Rank Discrete Lyapunov Equations with a regular Discrete
+>Lyapunov Equations solver
+>
+>Solving the Discrete Lyapunov Equations with a Low-rank Discrete Lyapunov
+>Equations solver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>fixed_smith
+>-----------
+>
+>
+>
+>Solving the Discrete Lyapunov Equations with a regular LinearSolver
+>DleSolversmith LrDleSolversmith
+>
+>>List of available options
+>
+>+------+------------+---------+----------------------------+
+>| Id | Type | Default | Description |
+>+======+============+=========+============================+
+>| iter | OT_INTEGER | 100 | Number of Smith iterations |
+>+------+------------+---------+----------------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>smith
+>-----
+>
+>
+>
+>Solving the Low-rank Discrete Lyapunov Equations with Smith iterations
+>
+>DleSolversmith LrDleSolversmith
+>
+>Implementation details: We avoid ever holding P in memory as it might be
+>large norm_inf_mul_tt was used to obtain a stopping criteria
+>
+>We avoid memory allocation in evaluate. All sparsity pattern calculations
+>have been done at init
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| max_iter | OT_INTEGER | 100 | Maximum number |
+>| | | | of iterations |
+>| | | | for the |
+>| | | | algorithm |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_iteration | OT_BOOLEAN | false | Print |
+>| | | | information |
+>| | | | about each |
+>| | | | iteration |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol | OT_REAL | 0.000 | Tolerance for |
+>| | | | satisfying the |
+>| | | | Lyapunov |
+>| | | | equation. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available stats
+>
+>+------------+
+>| Id |
+>+============+
+>| iter_count |
+>+------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: lr_dle_solver.hpp
+-}
+newtype LrDleSolver = LrDleSolver (ForeignPtr LrDleSolver')
+-- typeclass decl
+class LrDleSolverClass a where
+ castLrDleSolver :: a -> LrDleSolver
+instance LrDleSolverClass LrDleSolver where
+ castLrDleSolver = id
+
+-- baseclass instances
+instance FunctionClass LrDleSolver where
+ castFunction (LrDleSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass LrDleSolver where
+ castOptionsFunctionality (LrDleSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass LrDleSolver where
+ castSharedObject (LrDleSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass LrDleSolver where
+ castIOInterfaceFunction (LrDleSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal LrDleSolver (Ptr LrDleSolver') where
+ marshal (LrDleSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (LrDleSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__LrDleSolver"
+ c_delete_casadi__LrDleSolver :: FunPtr (Ptr LrDleSolver' -> IO ())
+instance WrapReturn (Ptr LrDleSolver') LrDleSolver where
+ wrapReturn = (fmap LrDleSolver) . (newForeignPtr c_delete_casadi__LrDleSolver)
+
+
+-- raw decl
+data LrDpleSolver'
+-- data decl
+{-|
+>Base class for Discrete Periodic Lyapunov Equation Solvers.
+>
+>Given matrices $A_k$ and symmetric $V_k, k = 0..K-1$
+>
+>
+>
+>::
+>
+> A_k in R^(n x n)
+> V_k in R^n
+>
+>
+>
+>
+>provides all of $P_k$ that satisfy:
+>
+>
+>
+>::
+>
+> P_0 = A_(K-1)*P_(K-1)*A_(K-1)' + V_k
+> P_k+1 = A_k*P_k*A_k' + V_k for k = 1..K-1
+>
+>
+>
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::LR_DPLEInput (LR_DPLE_NUM_IN = 4) [lrdpleIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| LR_DPLE_A | a | A matrices (horzcat |
+>| | | when const_dim, |
+>| | | blkdiag otherwise) . |
+>+------------------------+------------------------+------------------------+
+>| LR_DPLE_V | v | V matrices (horzcat |
+>| | | when const_dim, |
+>| | | blkdiag otherwise) . |
+>+------------------------+------------------------+------------------------+
+>| LR_DPLE_C | c | C matrix . |
+>+------------------------+------------------------+------------------------+
+>| LR_DPLE_H | h | H matrix: horizontal |
+>| | | stack of all Hi . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::LR_DPLEOutput (LR_DPLE_NUM_OUT = 1) [lrdpleOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| LR_DPLE_Y | y | Lyapunov matrix |
+>| | | (horzcat when |
+>| | | const_dim, blkdiag |
+>| | | otherwise) (Cholesky |
+>| | | of P if pos_def) . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| const_dim | OT_BOOLEAN | true | Assume | casadi::LrDp |
+>| | | | constant | leInternal |
+>| | | | dimension of | |
+>| | | | P | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| eps_unstable | OT_REAL | 0.000 | A margin for | casadi::LrDp |
+>| | | | unstability | leInternal |
+>| | | | detection | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| error_unstab | OT_BOOLEAN | false | Throw an | casadi::LrDp |
+>| le | | | exception | leInternal |
+>| | | | when it is | |
+>| | | | detected | |
+>| | | | that | |
+>| | | | Product(A_i, | |
+>| | | | i=N..1) has | |
+>| | | | eigenvalues | |
+>| | | | greater than | |
+>| | | | 1-eps_unstab | |
+>| | | | le | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| pos_def | OT_BOOLEAN | false | Assume P | casadi::LrDp |
+>| | | | positive | leInternal |
+>| | | | definite | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- dple
+>
+>- lifting
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>LrDpleSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>dple
+>----
+>
+>
+>
+>Solving the Low-Rank Discrete Lyapunov Equations with a Low-Rank Discrete
+>Lyapunov Equations Solver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>lifting
+>-------
+>
+>
+>
+>Solving the Discrete Periodic Lyapunov Equations by lifting the entire
+>period to a single Discrete Lyapunov Equation
+>
+>>List of available options
+>
+>+------+-----------+---------+-----------------------------------+
+>| Id | Type | Default | Description |
+>+======+===========+=========+===================================+
+>| form | OT_STRING | "A" | The form of the lifting (A:0|B:1) |
+>+------+-----------+---------+-----------------------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: lr_dple_solver.hpp
+-}
+newtype LrDpleSolver = LrDpleSolver (ForeignPtr LrDpleSolver')
+-- typeclass decl
+class LrDpleSolverClass a where
+ castLrDpleSolver :: a -> LrDpleSolver
+instance LrDpleSolverClass LrDpleSolver where
+ castLrDpleSolver = id
+
+-- baseclass instances
+instance FunctionClass LrDpleSolver where
+ castFunction (LrDpleSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass LrDpleSolver where
+ castOptionsFunctionality (LrDpleSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass LrDpleSolver where
+ castSharedObject (LrDpleSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass LrDpleSolver where
+ castIOInterfaceFunction (LrDpleSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal LrDpleSolver (Ptr LrDpleSolver') where
+ marshal (LrDpleSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (LrDpleSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__LrDpleSolver"
+ c_delete_casadi__LrDpleSolver :: FunPtr (Ptr LrDpleSolver' -> IO ())
+instance WrapReturn (Ptr LrDpleSolver') LrDpleSolver where
+ wrapReturn = (fmap LrDpleSolver) . (newForeignPtr c_delete_casadi__LrDpleSolver)
+
+
+-- raw decl
+data MX'
+-- data decl
+{-|
+-}
+newtype MX = MX (ForeignPtr MX')
+-- typeclass decl
+class MXClass a where
+ castMX :: a -> MX
+instance MXClass MX where
+ castMX = id
+
+-- baseclass instances
+instance SharedObjectClass MX where
+ castSharedObject (MX x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal MX (Ptr MX') where
+ marshal (MX x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (MX x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__MX"
+ c_delete_casadi__MX :: FunPtr (Ptr MX' -> IO ())
+instance WrapReturn (Ptr MX') MX where
+ wrapReturn = (fmap MX) . (newForeignPtr c_delete_casadi__MX)
+
+
+-- raw decl
+data MXFunction'
+-- data decl
+{-|
+>General function mapping from/to MX.
+>
+>Joel Andersson
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: mx_function.hpp
+-}
+newtype MXFunction = MXFunction (ForeignPtr MXFunction')
+-- typeclass decl
+class MXFunctionClass a where
+ castMXFunction :: a -> MXFunction
+instance MXFunctionClass MXFunction where
+ castMXFunction = id
+
+-- baseclass instances
+instance FunctionClass MXFunction where
+ castFunction (MXFunction x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass MXFunction where
+ castOptionsFunctionality (MXFunction x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass MXFunction where
+ castSharedObject (MXFunction x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass MXFunction where
+ castIOInterfaceFunction (MXFunction x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal MXFunction (Ptr MXFunction') where
+ marshal (MXFunction x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (MXFunction x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__MXFunction"
+ c_delete_casadi__MXFunction :: FunPtr (Ptr MXFunction' -> IO ())
+instance WrapReturn (Ptr MXFunction') MXFunction where
+ wrapReturn = (fmap MXFunction) . (newForeignPtr c_delete_casadi__MXFunction)
+
+
+-- raw decl
+data NlpSolver'
+-- data decl
+{-|
+>NlpSolver.
+>
+>Solves the following parametric nonlinear program (NLP):
+>
+>::
+>
+> min F(x, p)
+> x
+>
+> subject to
+> LBX <= x <= UBX
+> LBG <= G(x, p) <= UBG
+> p == P
+>
+> nx: number of decision variables
+> ng: number of constraints
+> np: number of parameters
+>
+>
+>
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::NlpSolverInput (NLP_SOLVER_NUM_IN = 8) [nlpSolverIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| NLP_SOLVER_X0 | x0 | Decision variables, |
+>| | | initial guess (nx x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_P | p | Value of fixed |
+>| | | parameters (np x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LBX | lbx | Decision variables |
+>| | | lower bound (nx x 1), |
+>| | | default -inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_UBX | ubx | Decision variables |
+>| | | upper bound (nx x 1), |
+>| | | default +inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LBG | lbg | Constraints lower |
+>| | | bound (ng x 1), |
+>| | | default -inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_UBG | ubg | Constraints upper |
+>| | | bound (ng x 1), |
+>| | | default +inf . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_X0 | lam_x0 | Lagrange multipliers |
+>| | | for bounds on X, |
+>| | | initial guess (nx x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_G0 | lam_g0 | Lagrange multipliers |
+>| | | for bounds on G, |
+>| | | initial guess (ng x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::NlpSolverOutput (NLP_SOLVER_NUM_OUT = 6) [nlpSolverOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| NLP_SOLVER_X | x | Decision variables at |
+>| | | the optimal solution |
+>| | | (nx x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_F | f | Cost function value at |
+>| | | the optimal solution |
+>| | | (1 x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_G | g | Constraints function |
+>| | | at the optimal |
+>| | | solution (ng x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_X | lam_x | Lagrange multipliers |
+>| | | for bounds on X at the |
+>| | | solution (nx x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_G | lam_g | Lagrange multipliers |
+>| | | for bounds on G at the |
+>| | | solution (ng x 1) . |
+>+------------------------+------------------------+------------------------+
+>| NLP_SOLVER_LAM_P | lam_p | Lagrange multipliers |
+>| | | for bounds on P at the |
+>| | | solution (np x 1) . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| eval_errors_ | OT_BOOLEAN | false | When errors | casadi::NlpS |
+>| fatal | | | occur during | olverInterna |
+>| | | | evaluation | l |
+>| | | | of | |
+>| | | | f,g,...,stop | |
+>| | | | the | |
+>| | | | iterations | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| expand | OT_BOOLEAN | false | Expand the | casadi::NlpS |
+>| | | | NLP function | olverInterna |
+>| | | | in terms of | l |
+>| | | | scalar | |
+>| | | | operations, | |
+>| | | | i.e. MX->SX | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| grad_f | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
+>| | | ) | calculating | olverInterna |
+>| | | | the gradient | l |
+>| | | | of the | |
+>| | | | objective | |
+>| | | | (column, aut | |
+>| | | | ogenerated | |
+>| | | | by default) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| grad_lag | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
+>| | | ) | calculating | olverInterna |
+>| | | | the gradient | l |
+>| | | | of the | |
+>| | | | Lagrangian ( | |
+>| | | | autogenerate | |
+>| | | | d by | |
+>| | | | default) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| hess_lag | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
+>| | | ) | calculating | olverInterna |
+>| | | | the Hessian | l |
+>| | | | of the | |
+>| | | | Lagrangian ( | |
+>| | | | autogenerate | |
+>| | | | d by | |
+>| | | | default) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| ignore_check | OT_BOOLEAN | false | If set to | casadi::NlpS |
+>| _vec | | | true, the | olverInterna |
+>| | | | input shape | l |
+>| | | | of F will | |
+>| | | | not be | |
+>| | | | checked. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| iteration_ca | OT_CALLBACK | GenericType( | A function | casadi::NlpS |
+>| llback | | ) | that will be | olverInterna |
+>| | | | called at | l |
+>| | | | each | |
+>| | | | iteration | |
+>| | | | with the | |
+>| | | | solver as | |
+>| | | | input. Check | |
+>| | | | documentatio | |
+>| | | | n of | |
+>| | | | Callback . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| iteration_ca | OT_BOOLEAN | false | If set to | casadi::NlpS |
+>| llback_ignor | | | true, errors | olverInterna |
+>| e_errors | | | thrown by it | l |
+>| | | | eration_call | |
+>| | | | back will be | |
+>| | | | ignored. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| iteration_ca | OT_INTEGER | 1 | Only call | casadi::NlpS |
+>| llback_step | | | the callback | olverInterna |
+>| | | | function | l |
+>| | | | every few | |
+>| | | | iterations. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| jac_f | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
+>| | | ) | calculating | olverInterna |
+>| | | | the jacobian | l |
+>| | | | of the | |
+>| | | | objective | |
+>| | | | (sparse row, | |
+>| | | | autogenerate | |
+>| | | | d by | |
+>| | | | default) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| jac_g | OT_FUNCTION | GenericType( | Function for | casadi::NlpS |
+>| | | ) | calculating | olverInterna |
+>| | | | the Jacobian | l |
+>| | | | of the | |
+>| | | | constraints | |
+>| | | | (autogenerat | |
+>| | | | ed by | |
+>| | | | default) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| warn_initial | OT_BOOLEAN | false | Warn if the | casadi::NlpS |
+>| _bounds | | | initial | olverInterna |
+>| | | | guess does | l |
+>| | | | not satisfy | |
+>| | | | LBX and UBX | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- ipopt
+>
+>- knitro
+>
+>- snopt
+>
+>- worhp
+>
+>- scpgen
+>
+>- sqpmethod
+>
+>- stabilizedsqp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>NlpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>ipopt
+>-----
+>
+>
+>
+>When in warmstart mode, output NLP_SOLVER_LAM_X may be used as input
+>
+>NOTE: Even when max_iter == 0, it is not guaranteed that
+>input(NLP_SOLVER_X0) == output(NLP_SOLVER_X). Indeed if bounds on X or
+>constraints are unmet, they will differ.
+>
+>For a good tutorial on IPOPT,
+>seehttp://drops.dagstuhl.de/volltexte/2009/2089/pdf/09061.WaechterAndreas.Paper.2089.pdf
+>
+>A good resource about the algorithms in IPOPT is: Wachter and L. T. Biegler,
+>On the Implementation of an Interior-Point Filter Line-Search Algorithm for
+>Large-Scale Nonlinear Programming, Mathematical Programming 106(1), pp.
+>25-57, 2006 (As Research Report RC 23149, IBM T. J. Watson Research Center,
+>Yorktown, USA
+>
+>Caveats: with default options, multipliers for the decision variables are
+>wrong for equality constraints. Change the 'fixed_variable_treatment' to
+>'make_constraint' or 'relax_bounds' to obtain correct results.
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| accept_after_ma | OT_INTEGER | -1 | Accept a trial |
+>| x_steps | | | point after |
+>| | | | maximal this |
+>| | | | number of |
+>| | | | steps. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| accept_every_tr | OT_STRING | no | Always accept |
+>| ial_step | | | the first trial |
+>| | | | step. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| acceptable_comp | OT_REAL | 0.010 | "Acceptance" |
+>| l_inf_tol | | | threshold for |
+>| | | | the |
+>| | | | complementarity |
+>| | | | conditions. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| acceptable_cons | OT_REAL | 0.010 | "Acceptance" |
+>| tr_viol_tol | | | threshold for |
+>| | | | the constraint |
+>| | | | violation. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| acceptable_dual | OT_REAL | 1.000e+10 | "Acceptance" |
+>| _inf_tol | | | threshold for |
+>| | | | the dual |
+>| | | | infeasibility. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| acceptable_iter | OT_INTEGER | 15 | Number of |
+>| | | | "acceptable" |
+>| | | | iterates before |
+>| | | | triggering |
+>| | | | termination. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| acceptable_obj_ | OT_REAL | 1.000e+20 | "Acceptance" |
+>| change_tol | | | stopping |
+>| | | | criterion based |
+>| | | | on objective |
+>| | | | function |
+>| | | | change. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| acceptable_tol | OT_REAL | 0.000 | "Acceptable" |
+>| | | | convergence |
+>| | | | tolerance |
+>| | | | (relative). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| adaptive_mu_glo | OT_STRING | obj-constr- | Globalization |
+>| balization | | filter | strategy for |
+>| | | | the adaptive mu |
+>| | | | selection mode. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| adaptive_mu_kkt | OT_STRING | 2-norm-squared | Norm used for |
+>| _norm_type | | | the KKT error |
+>| | | | in the adaptive |
+>| | | | mu |
+>| | | | globalization |
+>| | | | strategies. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| adaptive_mu_kkt | OT_REAL | 1.000 | Sufficient |
+>| error_red_fact | | | decrease factor |
+>| | | | for "kkt-error" |
+>| | | | globalization |
+>| | | | strategy. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| adaptive_mu_kkt | OT_INTEGER | 4 | Maximum number |
+>| error_red_iters | | | of iterations |
+>| | | | requiring |
+>| | | | sufficient |
+>| | | | progress. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| adaptive_mu_mon | OT_REAL | 0.800 | Determines the |
+>| otone_init_fact | | | initial value |
+>| or | | | of the barrier |
+>| | | | parameter when |
+>| | | | switching to |
+>| | | | the monotone |
+>| | | | mode. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| adaptive_mu_res | OT_STRING | no | Indicates if |
+>| tore_previous_i | | | the previous |
+>| terate | | | iterate should |
+>| | | | be restored if |
+>| | | | the monotone |
+>| | | | mode is |
+>| | | | entered. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| adaptive_mu_saf | OT_REAL | 0 | (see IPOPT |
+>| eguard_factor | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| alpha_for_y | OT_STRING | primal | Method to |
+>| | | | determine the |
+>| | | | step size for |
+>| | | | constraint |
+>| | | | multipliers. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| alpha_for_y_tol | OT_REAL | 10 | Tolerance for |
+>| | | | switching to |
+>| | | | full equality |
+>| | | | multiplier |
+>| | | | steps. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| alpha_min_frac | OT_REAL | 0.050 | Safety factor |
+>| | | | for the minimal |
+>| | | | step size |
+>| | | | (before |
+>| | | | switching to |
+>| | | | restoration |
+>| | | | phase). (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| alpha_red_facto | OT_REAL | 0.500 | Fractional |
+>| r | | | reduction of |
+>| | | | the trial step |
+>| | | | size in the |
+>| | | | backtracking |
+>| | | | line search. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| barrier_tol_fac | OT_REAL | 10 | Factor for mu |
+>| tor | | | in barrier stop |
+>| | | | test. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| bound_frac | OT_REAL | 0.010 | Desired minimum |
+>| | | | relative |
+>| | | | distance from |
+>| | | | the initial |
+>| | | | point to bound. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| bound_mult_init | OT_STRING | constant | Initialization |
+>| _method | | | method for |
+>| | | | bound |
+>| | | | multipliers |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| bound_mult_init | OT_REAL | 1 | Initial value |
+>| _val | | | for the bound |
+>| | | | multipliers. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| bound_mult_rese | OT_REAL | 1000 | Threshold for |
+>| t_threshold | | | resetting bound |
+>| | | | multipliers |
+>| | | | after the |
+>| | | | restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| bound_push | OT_REAL | 0.010 | Desired minimum |
+>| | | | absolute |
+>| | | | distance from |
+>| | | | the initial |
+>| | | | point to bound. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| bound_relax_fac | OT_REAL | 0.000 | Factor for |
+>| tor | | | initial |
+>| | | | relaxation of |
+>| | | | the bounds. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| check_derivativ | OT_STRING | no | Indicates |
+>| es_for_naninf | | | whether it is |
+>| | | | desired to |
+>| | | | check for |
+>| | | | Nan/Inf in |
+>| | | | derivative |
+>| | | | matrices (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| chi_cup | OT_REAL | 1.500 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| chi_hat | OT_REAL | 2 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| chi_tilde | OT_REAL | 5 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| compl_inf_tol | OT_REAL | 0.000 | Desired |
+>| | | | threshold for |
+>| | | | the |
+>| | | | complementarity |
+>| | | | conditions. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| con_integer_md | OT_DICTIONARY | None | Integer |
+>| | | | metadata (a |
+>| | | | dictionary with |
+>| | | | lists of |
+>| | | | integers) about |
+>| | | | constraints to |
+>| | | | be passed to |
+>| | | | IPOPT |
+>+-----------------+-----------------+-----------------+-----------------+
+>| con_numeric_md | OT_DICTIONARY | None | Numeric |
+>| | | | metadata (a |
+>| | | | dictionary with |
+>| | | | lists of reals) |
+>| | | | about |
+>| | | | constraints to |
+>| | | | be passed to |
+>| | | | IPOPT |
+>+-----------------+-----------------+-----------------+-----------------+
+>| con_string_md | OT_DICTIONARY | None | String metadata |
+>| | | | (a dictionary |
+>| | | | with lists of |
+>| | | | strings) about |
+>| | | | constraints to |
+>| | | | be passed to |
+>| | | | IPOPT |
+>+-----------------+-----------------+-----------------+-----------------+
+>| constr_mult_ini | OT_REAL | 1000 | Maximum allowed |
+>| t_max | | | least-square |
+>| | | | guess of |
+>| | | | constraint |
+>| | | | multipliers. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| constr_mult_res | OT_REAL | 0 | Threshold for |
+>| et_threshold | | | resetting |
+>| | | | equality and |
+>| | | | inequality |
+>| | | | multipliers |
+>| | | | after |
+>| | | | restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| constr_viol_tol | OT_REAL | 0.000 | Desired |
+>| | | | threshold for |
+>| | | | the constraint |
+>| | | | violation. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| constraint_viol | OT_STRING | 1-norm | Norm to be used |
+>| ation_norm_type | | | for the |
+>| | | | constraint |
+>| | | | violation in |
+>| | | | the line |
+>| | | | search. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| corrector_compl | OT_REAL | 1 | Complementarity |
+>| _avrg_red_fact | | | tolerance |
+>| | | | factor for |
+>| | | | accepting |
+>| | | | corrector step |
+>| | | | (unsupported!). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| corrector_type | OT_STRING | none | The type of |
+>| | | | corrector steps |
+>| | | | that should be |
+>| | | | taken |
+>| | | | (unsupported!). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| delta | OT_REAL | 1 | Multiplier for |
+>| | | | constraint |
+>| | | | violation in |
+>| | | | the switching |
+>| | | | rule. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| delta_y_max | OT_REAL | 1.000e+12 | a parameter |
+>| | | | used to check |
+>| | | | if the fast |
+>| | | | direction can |
+>| | | | be used asthe |
+>| | | | line search |
+>| | | | direction (for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dependency_dete | OT_STRING | no | Indicates if |
+>| ction_with_rhs | | | the right hand |
+>| | | | sides of the |
+>| | | | constraints |
+>| | | | should be |
+>| | | | considered |
+>| | | | during |
+>| | | | dependency |
+>| | | | detection (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dependency_dete | OT_STRING | none | Indicates which |
+>| ctor | | | linear solver |
+>| | | | should be used |
+>| | | | to detect |
+>| | | | linearly |
+>| | | | dependent |
+>| | | | equality |
+>| | | | constraints. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| derivative_test | OT_STRING | none | Enable |
+>| | | | derivative |
+>| | | | checker (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| derivative_test | OT_INTEGER | -2 | Index of first |
+>| _first_index | | | quantity to be |
+>| | | | checked by |
+>| | | | derivative |
+>| | | | checker (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| derivative_test | OT_REAL | 0.000 | Size of the |
+>| _perturbation | | | finite |
+>| | | | difference |
+>| | | | perturbation in |
+>| | | | derivative |
+>| | | | test. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| derivative_test | OT_STRING | no | Indicates |
+>| _print_all | | | whether |
+>| | | | information for |
+>| | | | all estimated |
+>| | | | derivatives |
+>| | | | should be |
+>| | | | printed. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| derivative_test | OT_REAL | 0.000 | Threshold for |
+>| _tol | | | indicating |
+>| | | | wrong |
+>| | | | derivative. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| diverging_itera | OT_REAL | 1.000e+20 | Threshold for |
+>| tes_tol | | | maximal value |
+>| | | | of primal |
+>| | | | iterates. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dual_inf_tol | OT_REAL | 1 | Desired |
+>| | | | threshold for |
+>| | | | the dual |
+>| | | | infeasibility. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsilon_c | OT_REAL | 0.010 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| eta_min | OT_REAL | 10 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| eta_penalty | OT_REAL | 0.000 | Relaxation |
+>| | | | factor in the |
+>| | | | Armijo |
+>| | | | condition for |
+>| | | | the penalty |
+>| | | | function. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| eta_phi | OT_REAL | 0.000 | Relaxation |
+>| | | | factor in the |
+>| | | | Armijo |
+>| | | | condition. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| evaluate_orig_o | OT_STRING | yes | Determines if |
+>| bj_at_resto_tri | | | the original |
+>| al | | | objective |
+>| | | | function should |
+>| | | | be evaluated at |
+>| | | | restoration |
+>| | | | phase trial |
+>| | | | points. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| expect_infeasib | OT_STRING | no | Enable |
+>| le_problem | | | heuristics to |
+>| | | | quickly detect |
+>| | | | an infeasible |
+>| | | | problem. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| expect_infeasib | OT_REAL | 0.001 | Threshold for |
+>| le_problem_ctol | | | disabling "expe |
+>| | | | ct_infeasible_p |
+>| | | | roblem" option. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| expect_infeasib | OT_REAL | 100000000 | Multiplier |
+>| le_problem_ytol | | | threshold for |
+>| | | | activating "exp |
+>| | | | ect_infeasible_ |
+>| | | | problem" |
+>| | | | option. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fast_des_fact | OT_REAL | 0.100 | a parameter |
+>| | | | used to check |
+>| | | | if the fast |
+>| | | | direction can |
+>| | | | be used asthe |
+>| | | | line search |
+>| | | | direction (for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fast_step_compu | OT_STRING | no | Indicates if |
+>| tation | | | the linear |
+>| | | | system should |
+>| | | | be solved |
+>| | | | quickly. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| file_print_leve | OT_INTEGER | 5 | Verbosity level |
+>| l | | | for output |
+>| | | | file. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| filter_margin_f | OT_REAL | 0.000 | Factor |
+>| act | | | determining |
+>| | | | width of margin |
+>| | | | for obj-constr- |
+>| | | | filter adaptive |
+>| | | | globalization |
+>| | | | strategy. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| filter_max_marg | OT_REAL | 1 | Maximum width |
+>| in | | | of margin in |
+>| | | | obj-constr- |
+>| | | | filter adaptive |
+>| | | | globalization |
+>| | | | strategy. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| filter_reset_tr | OT_INTEGER | 5 | Number of |
+>| igger | | | iterations that |
+>| | | | trigger the |
+>| | | | filter reset. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| findiff_perturb | OT_REAL | 0.000 | Size of the |
+>| ation | | | finite |
+>| | | | difference |
+>| | | | perturbation |
+>| | | | for derivative |
+>| | | | approximation. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| first_hessian_p | OT_REAL | 0.000 | Size of first |
+>| erturbation | | | x-s |
+>| | | | perturbation |
+>| | | | tried. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fixed_mu_oracle | OT_STRING | average_compl | Oracle for the |
+>| | | | barrier |
+>| | | | parameter when |
+>| | | | switching to |
+>| | | | fixed mode. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| fixed_variable_ | OT_STRING | make_parameter | Determines how |
+>| treatment | | | fixed variables |
+>| | | | should be |
+>| | | | handled. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gamma_hat | OT_REAL | 0.040 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gamma_phi | OT_REAL | 0.000 | Relaxation |
+>| | | | factor in the |
+>| | | | filter margin |
+>| | | | for the barrier |
+>| | | | function. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gamma_theta | OT_REAL | 0.000 | Relaxation |
+>| | | | factor in the |
+>| | | | filter margin |
+>| | | | for the |
+>| | | | constraint |
+>| | | | violation. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gamma_tilde | OT_REAL | 4 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| hessian_approxi | OT_STRING | exact | Indicates what |
+>| mation | | | Hessian |
+>| | | | information is |
+>| | | | to be used. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| hessian_approxi | OT_STRING | nonlinear- | Indicates in |
+>| mation_space | | variables | which subspace |
+>| | | | the Hessian |
+>| | | | information is |
+>| | | | to be |
+>| | | | approximated. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| hessian_constan | OT_STRING | no | Indicates |
+>| t | | | whether the |
+>| | | | problem is a |
+>| | | | quadratic |
+>| | | | problem (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| honor_original_ | OT_STRING | yes | Indicates |
+>| bounds | | | whether final |
+>| | | | points should |
+>| | | | be projected |
+>| | | | into original |
+>| | | | bounds. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| inf_pr_output | OT_STRING | original | Determines what |
+>| | | | value is |
+>| | | | printed in the |
+>| | | | "inf_pr" output |
+>| | | | column. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| jac_c_constant | OT_STRING | no | Indicates |
+>| | | | whether all |
+>| | | | equality |
+>| | | | constraints are |
+>| | | | linear (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| jac_d_constant | OT_STRING | no | Indicates |
+>| | | | whether all |
+>| | | | inequality |
+>| | | | constraints are |
+>| | | | linear (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| jacobian_approx | OT_STRING | exact | Specifies |
+>| imation | | | technique to |
+>| | | | compute |
+>| | | | constraint |
+>| | | | Jacobian (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| jacobian_regula | OT_REAL | 0.250 | Exponent for mu |
+>| rization_expone | | | in the |
+>| nt | | | regularization |
+>| | | | for rank- |
+>| | | | deficient |
+>| | | | constraint |
+>| | | | Jacobians. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| jacobian_regula | OT_REAL | 0.000 | Size of the |
+>| rization_value | | | regularization |
+>| | | | for rank- |
+>| | | | deficient |
+>| | | | constraint |
+>| | | | Jacobians. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| kappa_d | OT_REAL | 0.000 | Weight for |
+>| | | | linear damping |
+>| | | | term (to handle |
+>| | | | one-sided |
+>| | | | bounds). (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| kappa_sigma | OT_REAL | 1.000e+10 | Factor limiting |
+>| | | | the deviation |
+>| | | | of dual |
+>| | | | variables from |
+>| | | | primal |
+>| | | | estimates. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| kappa_soc | OT_REAL | 0.990 | Factor in the |
+>| | | | sufficient |
+>| | | | reduction rule |
+>| | | | for second |
+>| | | | order |
+>| | | | correction. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| kappa_x_dis | OT_REAL | 100 | a parameter |
+>| | | | used to check |
+>| | | | if the fast |
+>| | | | direction can |
+>| | | | be used asthe |
+>| | | | line search |
+>| | | | direction (for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| kappa_y_dis | OT_REAL | 10000 | a parameter |
+>| | | | used to check |
+>| | | | if the fast |
+>| | | | direction can |
+>| | | | be used asthe |
+>| | | | line search |
+>| | | | direction (for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| least_square_in | OT_STRING | no | Least square |
+>| it_duals | | | initialization |
+>| | | | of all dual |
+>| | | | variables (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| least_square_in | OT_STRING | no | Least square |
+>| it_primal | | | initialization |
+>| | | | of the primal |
+>| | | | variables (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_STRING | sherman- | Strategy for |
+>| aug_solver | | morrison | solving the |
+>| | | | augmented |
+>| | | | system for low- |
+>| | | | rank Hessian. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_REAL | 1 | Value for B0 in |
+>| init_val | | | low-rank |
+>| | | | update. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_REAL | 100000000 | Upper bound on |
+>| init_val_max | | | value for B0 in |
+>| | | | low-rank |
+>| | | | update. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_REAL | 0.000 | Lower bound on |
+>| init_val_min | | | value for B0 in |
+>| | | | low-rank |
+>| | | | update. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_STRING | scalar1 | Initialization |
+>| initialization | | | strategy for |
+>| | | | the limited |
+>| | | | memory quasi- |
+>| | | | Newton |
+>| | | | approximation. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_INTEGER | 6 | Maximum size of |
+>| max_history | | | the history for |
+>| | | | the limited |
+>| | | | quasi-Newton |
+>| | | | Hessian |
+>| | | | approximation. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_INTEGER | 2 | Threshold for |
+>| max_skipping | | | successive |
+>| | | | iterations |
+>| | | | where update is |
+>| | | | skipped. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_STRING | no | Determines if |
+>| special_for_res | | | the quasi- |
+>| to | | | Newton updates |
+>| | | | should be |
+>| | | | special during |
+>| | | | the restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| limited_memory_ | OT_STRING | bfgs | Quasi-Newton |
+>| update_type | | | update formula |
+>| | | | for the limited |
+>| | | | memory |
+>| | | | approximation. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| line_search_met | OT_STRING | filter | Globalization |
+>| hod | | | method used in |
+>| | | | backtracking |
+>| | | | line search |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_scaling_ | OT_STRING | yes | Flag indicating |
+>| on_demand | | | that linear |
+>| | | | scaling is only |
+>| | | | done if it |
+>| | | | seems required. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_solver | OT_STRING | mumps | Linear solver |
+>| | | | used for step |
+>| | | | computations. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| linear_system_s | OT_STRING | none | Method for |
+>| caling | | | scaling the |
+>| | | | linear system. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma27_ignore_sin | OT_STRING | no | Enables MA27's |
+>| gularity | | | ability to |
+>| | | | solve a linear |
+>| | | | system even if |
+>| | | | the matrix is |
+>| | | | singular. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma27_la_init_fa | OT_REAL | 5 | Real workspace |
+>| ctor | | | memory for |
+>| | | | MA27. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma27_liw_init_f | OT_REAL | 5 | Integer |
+>| actor | | | workspace |
+>| | | | memory for |
+>| | | | MA27. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma27_meminc_fac | OT_REAL | 2 | Increment |
+>| tor | | | factor for |
+>| | | | workspace size |
+>| | | | for MA27. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma27_pivtol | OT_REAL | 0.000 | Pivot tolerance |
+>| | | | for the linear |
+>| | | | solver MA27. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma27_pivtolmax | OT_REAL | 0.000 | Maximum pivot |
+>| | | | tolerance for |
+>| | | | the linear |
+>| | | | solver MA27. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma27_skip_inert | OT_STRING | no | Always pretend |
+>| ia_check | | | inertia is |
+>| | | | correct. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma28_pivtol | OT_REAL | 0.010 | Pivot tolerance |
+>| | | | for linear |
+>| | | | solver MA28. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_automatic_ | OT_STRING | no | Controls MA57 |
+>| scaling | | | automatic |
+>| | | | scaling (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_block_size | OT_INTEGER | 16 | Controls block |
+>| | | | size used by |
+>| | | | Level 3 BLAS in |
+>| | | | MA57BD (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_node_amalg | OT_INTEGER | 16 | Node |
+>| amation | | | amalgamation |
+>| | | | parameter (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_pivot_orde | OT_INTEGER | 5 | Controls pivot |
+>| r | | | order in MA57 |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_pivtol | OT_REAL | 0.000 | Pivot tolerance |
+>| | | | for the linear |
+>| | | | solver MA57. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_pivtolmax | OT_REAL | 0.000 | Maximum pivot |
+>| | | | tolerance for |
+>| | | | the linear |
+>| | | | solver MA57. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_pre_alloc | OT_REAL | 1.050 | Safety factor |
+>| | | | for work space |
+>| | | | memory |
+>| | | | allocation for |
+>| | | | the linear |
+>| | | | solver MA57. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma57_small_pivo | OT_INTEGER | 0 | If set to 1, |
+>| t_flag | | | then when small |
+>| | | | entries defined |
+>| | | | by CNTL(2) are |
+>| | | | detected they |
+>| | | | are removed and |
+>| | | | the |
+>| | | | corresponding |
+>| | | | pivots placed |
+>| | | | at the end of |
+>| | | | the |
+>| | | | factorization. |
+>| | | | This can be |
+>| | | | particularly |
+>| | | | efficient if |
+>| | | | the matrix is |
+>| | | | highly rank |
+>| | | | deficient. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_buffer_lpa | OT_INTEGER | 4096 | Number of |
+>| ge | | | scalars per |
+>| | | | MA77 buffer |
+>| | | | page (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_buffer_npa | OT_INTEGER | 1600 | Number of pages |
+>| ge | | | that make up |
+>| | | | MA77 buffer |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_file_size | OT_INTEGER | 2097152 | Target size of |
+>| | | | each temporary |
+>| | | | file for MA77, |
+>| | | | scalars per |
+>| | | | type (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_maxstore | OT_INTEGER | 0 | Maximum storage |
+>| | | | size for MA77 |
+>| | | | in-core mode |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_nemin | OT_INTEGER | 8 | Node |
+>| | | | Amalgamation |
+>| | | | parameter (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_order | OT_STRING | amd | Controls type |
+>| | | | of ordering |
+>| | | | used by |
+>| | | | HSL_MA77 (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_print_leve | OT_INTEGER | -1 | Debug printing |
+>| l | | | level for the |
+>| | | | linear solver |
+>| | | | MA77 (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_small | OT_REAL | 0.000 | Zero Pivot |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_static | OT_REAL | 0 | Static Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_u | OT_REAL | 0.000 | Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma77_umax | OT_REAL | 0.000 | Maximum |
+>| | | | Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_nemin | OT_INTEGER | 32 | Node |
+>| | | | Amalgamation |
+>| | | | parameter (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_order | OT_STRING | amd | Controls type |
+>| | | | of ordering |
+>| | | | used by |
+>| | | | HSL_MA86 (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_print_leve | OT_INTEGER | -1 | Debug printing |
+>| l | | | level for the |
+>| | | | linear solver |
+>| | | | MA86 (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_scaling | OT_STRING | mc64 | Controls |
+>| | | | scaling of |
+>| | | | matrix (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_small | OT_REAL | 0.000 | Zero Pivot |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_static | OT_REAL | 0 | Static Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_u | OT_REAL | 0.000 | Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma86_umax | OT_REAL | 0.000 | Maximum |
+>| | | | Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_nemin | OT_INTEGER | 8 | Node |
+>| | | | Amalgamation |
+>| | | | parameter (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_order | OT_STRING | auto | Controls type |
+>| | | | of ordering |
+>| | | | used by |
+>| | | | HSL_MA97 (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_print_leve | OT_INTEGER | 0 | Debug printing |
+>| l | | | level for the |
+>| | | | linear solver |
+>| | | | MA97 (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_scaling | OT_STRING | dynamic | Specifies |
+>| | | | strategy for |
+>| | | | scaling in |
+>| | | | HSL_MA97 linear |
+>| | | | solver (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_scaling1 | OT_STRING | mc64 | First scaling. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_scaling2 | OT_STRING | mc64 | Second scaling. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_scaling3 | OT_STRING | mc64 | Third scaling. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_small | OT_REAL | 0.000 | Zero Pivot |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_solve_blas | OT_STRING | no | Controls if |
+>| 3 | | | blas2 or blas3 |
+>| | | | routines are |
+>| | | | used for solve |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_switch1 | OT_STRING | od_hd_reuse | First switch, |
+>| | | | determine when |
+>| | | | ma97_scaling1 |
+>| | | | is enabled. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_switch2 | OT_STRING | never | Second switch, |
+>| | | | determine when |
+>| | | | ma97_scaling2 |
+>| | | | is enabled. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_switch3 | OT_STRING | never | Third switch, |
+>| | | | determine when |
+>| | | | ma97_scaling3 |
+>| | | | is enabled. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_u | OT_REAL | 0.000 | Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ma97_umax | OT_REAL | 0.000 | Maximum |
+>| | | | Pivoting |
+>| | | | Threshold (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| magic_steps | OT_STRING | no | Enables magic |
+>| | | | steps. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_cpu_time | OT_REAL | 1000000 | Maximum number |
+>| | | | of CPU seconds. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_filter_rese | OT_INTEGER | 5 | Maximal allowed |
+>| ts | | | number of |
+>| | | | filter resets |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_hessian_per | OT_REAL | 1.000e+20 | Maximum value |
+>| turbation | | | of |
+>| | | | regularization |
+>| | | | parameter for |
+>| | | | handling |
+>| | | | negative |
+>| | | | curvature. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter | OT_INTEGER | 3000 | Maximum number |
+>| | | | of iterations. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_refinement_ | OT_INTEGER | 10 | Maximum number |
+>| steps | | | of iterative |
+>| | | | refinement |
+>| | | | steps per |
+>| | | | linear system |
+>| | | | solve. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_resto_iter | OT_INTEGER | 3000000 | Maximum number |
+>| | | | of successive |
+>| | | | iterations in |
+>| | | | restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_soc | OT_INTEGER | 4 | Maximum number |
+>| | | | of second order |
+>| | | | correction |
+>| | | | trial steps at |
+>| | | | each iteration. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_soft_resto_ | OT_INTEGER | 10 | Maximum number |
+>| iters | | | of iterations |
+>| | | | performed |
+>| | | | successively in |
+>| | | | soft |
+>| | | | restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mehrotra_algori | OT_STRING | no | Indicates if we |
+>| thm | | | want to do |
+>| | | | Mehrotra's |
+>| | | | algorithm. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| min_alpha_prima | OT_REAL | 0.000 | LIFENG WRITES |
+>| l | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| min_hessian_per | OT_REAL | 0.000 | Smallest |
+>| turbation | | | perturbation of |
+>| | | | the Hessian |
+>| | | | block. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| min_refinement_ | OT_INTEGER | 1 | Minimum number |
+>| steps | | | of iterative |
+>| | | | refinement |
+>| | | | steps per |
+>| | | | linear system |
+>| | | | solve. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_allow_fast_m | OT_STRING | yes | Allow skipping |
+>| onotone_decreas | | | of barrier |
+>| e | | | problem if |
+>| | | | barrier test is |
+>| | | | already met. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_init | OT_REAL | 0.100 | Initial value |
+>| | | | for the barrier |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_linear_decre | OT_REAL | 0.200 | Determines |
+>| ase_factor | | | linear decrease |
+>| | | | rate of barrier |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_max | OT_REAL | 100000 | Maximum value |
+>| | | | for barrier |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_max_fact | OT_REAL | 1000 | Factor for |
+>| | | | initialization |
+>| | | | of maximum |
+>| | | | value for |
+>| | | | barrier |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_min | OT_REAL | 0.000 | Minimum value |
+>| | | | for barrier |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_oracle | OT_STRING | quality- | Oracle for a |
+>| | | function | new barrier |
+>| | | | parameter in |
+>| | | | the adaptive |
+>| | | | strategy. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_strategy | OT_STRING | monotone | Update strategy |
+>| | | | for barrier |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_superlinear_ | OT_REAL | 1.500 | Determines |
+>| decrease_power | | | superlinear |
+>| | | | decrease rate |
+>| | | | of barrier |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mu_target | OT_REAL | 0 | Desired value |
+>| | | | of complementar |
+>| | | | ity. (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mult_diverg_fea | OT_REAL | 0.000 | tolerance for |
+>| sibility_tol | | | deciding if the |
+>| | | | multipliers are |
+>| | | | diverging (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mult_diverg_y_t | OT_REAL | 100000000 | tolerance for |
+>| ol | | | deciding if the |
+>| | | | multipliers are |
+>| | | | diverging (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mumps_dep_tol | OT_REAL | 0 | Pivot threshold |
+>| | | | for detection |
+>| | | | of linearly |
+>| | | | dependent |
+>| | | | constraints in |
+>| | | | MUMPS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mumps_mem_perce | OT_INTEGER | 1000 | Percentage |
+>| nt | | | increase in the |
+>| | | | estimated |
+>| | | | working space |
+>| | | | for MUMPS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mumps_permuting | OT_INTEGER | 7 | Controls |
+>| _scaling | | | permuting and |
+>| | | | scaling in |
+>| | | | MUMPS (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mumps_pivot_ord | OT_INTEGER | 7 | Controls pivot |
+>| er | | | order in MUMPS |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mumps_pivtol | OT_REAL | 0.000 | Pivot tolerance |
+>| | | | for the linear |
+>| | | | solver MUMPS. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mumps_pivtolmax | OT_REAL | 0.100 | Maximum pivot |
+>| | | | tolerance for |
+>| | | | the linear |
+>| | | | solver MUMPS. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mumps_scaling | OT_INTEGER | 77 | Controls |
+>| | | | scaling in |
+>| | | | MUMPS (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| neg_curv_test_t | OT_REAL | 0 | Tolerance for |
+>| ol | | | heuristic to |
+>| | | | ignore wrong |
+>| | | | inertia. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| never_use_fact_ | OT_STRING | no | Toggle to |
+>| cgpen_direction | | | switch off the |
+>| | | | fast Chen- |
+>| | | | Goldfarb |
+>| | | | direction (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| never_use_piece | OT_STRING | no | Toggle to |
+>| wise_penalty_ls | | | switch off the |
+>| | | | piecewise |
+>| | | | penalty method |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_lower_bound | OT_REAL | -1.000e+19 | any bound less |
+>| _inf | | | or equal this |
+>| | | | value will be |
+>| | | | considered -inf |
+>| | | | (i.e. not lower |
+>| | | | bounded). (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_scaling_con | OT_REAL | 0 | Target value |
+>| str_target_grad | | | for constraint |
+>| ient | | | function |
+>| | | | gradient size. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_scaling_max | OT_REAL | 100 | Maximum |
+>| _gradient | | | gradient after |
+>| | | | NLP scaling. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_scaling_met | OT_STRING | gradient-based | Select the |
+>| hod | | | technique used |
+>| | | | for scaling the |
+>| | | | NLP. (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_scaling_min | OT_REAL | 0.000 | Minimum value |
+>| _value | | | of gradient- |
+>| | | | based scaling |
+>| | | | values. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_scaling_obj | OT_REAL | 0 | Target value |
+>| _target_gradien | | | for objective |
+>| t | | | function |
+>| | | | gradient size. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nlp_upper_bound | OT_REAL | 1.000e+19 | any bound |
+>| _inf | | | greater or this |
+>| | | | value will be |
+>| | | | considered +inf |
+>| | | | (i.e. not upper |
+>| | | | bounded). (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nu_inc | OT_REAL | 0.000 | Increment of |
+>| | | | the penalty |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nu_init | OT_REAL | 0.000 | Initial value |
+>| | | | of the penalty |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| num_linear_vari | OT_INTEGER | 0 | Number of |
+>| ables | | | linear |
+>| | | | variables (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| obj_max_inc | OT_REAL | 5 | Determines the |
+>| | | | upper bound on |
+>| | | | the acceptable |
+>| | | | increase of |
+>| | | | barrier |
+>| | | | objective |
+>| | | | function. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| obj_scaling_fac | OT_REAL | 1 | Scaling factor |
+>| tor | | | for the |
+>| | | | objective |
+>| | | | function. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| option_file_nam | OT_STRING | ipopt.opt | File name of |
+>| e | | | options file. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| output_file | OT_STRING | | File name of |
+>| | | | desired output |
+>| | | | file (leave |
+>| | | | unset for no |
+>| | | | file output). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iter_co | OT_INTEGER | 5000 | Maximum Size of |
+>| arse_size | | | Coarse Grid |
+>| | | | Matrix (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iter_dr | OT_REAL | 0.500 | dropping value |
+>| opping_factor | | | for incomplete |
+>| | | | factor (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iter_dr | OT_REAL | 0.100 | dropping value |
+>| opping_schur | | | for sparsify |
+>| | | | schur |
+>| | | | complement |
+>| | | | factor (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iter_in | OT_REAL | 5000000 | (see IPOPT |
+>| verse_norm_fact | | | documentation) |
+>| or | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iter_ma | OT_INTEGER | 10 | Maximum Size of |
+>| x_levels | | | Grid Levels |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iter_ma | OT_INTEGER | 10000000 | max fill for |
+>| x_row_fill | | | each row (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iter_re | OT_REAL | 0.000 | Relative |
+>| lative_tol | | | Residual |
+>| | | | Convergence |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_iterati | OT_STRING | no | Switch on |
+>| ve | | | iterative |
+>| | | | solver in |
+>| | | | Pardiso library |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_matchin | OT_STRING | complete+2x2 | Matching |
+>| g_strategy | | | strategy to be |
+>| | | | used by Pardiso |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_max_dro | OT_INTEGER | 4 | Maximal number |
+>| ptol_correction | | | of decreases of |
+>| s | | | drop tolerance |
+>| | | | during one |
+>| | | | solve. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_max_ite | OT_INTEGER | 500 | Maximum number |
+>| r | | | of Krylov- |
+>| | | | Subspace |
+>| | | | Iteration (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_msglvl | OT_INTEGER | 0 | Pardiso message |
+>| | | | level (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_out_of_ | OT_INTEGER | 0 | Enables out-of- |
+>| core_power | | | core variant of |
+>| | | | Pardiso (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_redo_sy | OT_STRING | no | Toggle for |
+>| mbolic_fact_onl | | | handling case |
+>| y_if_inertia_wr | | | when elements |
+>| ong | | | were perturbed |
+>| | | | by Pardiso. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_repeate | OT_STRING | no | Interpretation |
+>| d_perturbation_ | | | of perturbed |
+>| means_singular | | | elements. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pardiso_skip_in | OT_STRING | no | Always pretend |
+>| ertia_check | | | inertia is |
+>| | | | correct. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pass_nonlinear_ | OT_BOOLEAN | False | n/a |
+>| variables | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pen_des_fact | OT_REAL | 0.200 | a parameter |
+>| | | | used in penalty |
+>| | | | parameter |
+>| | | | computation |
+>| | | | (for Chen- |
+>| | | | Goldfarb line |
+>| | | | search). (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pen_init_fac | OT_REAL | 50 | a parameter |
+>| | | | used to choose |
+>| | | | initial penalty |
+>| | | | parameterswhen |
+>| | | | the regularized |
+>| | | | Newton method |
+>| | | | is used. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| pen_theta_max_f | OT_REAL | 10000 | Determines |
+>| act | | | upper bound for |
+>| | | | constraint |
+>| | | | violation in |
+>| | | | the filter. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| penalty_init_ma | OT_REAL | 100000 | Maximal value |
+>| x | | | for the intial |
+>| | | | penalty |
+>| | | | parameter (for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| penalty_init_mi | OT_REAL | 1 | Minimal value |
+>| n | | | for the intial |
+>| | | | penalty |
+>| | | | parameter for |
+>| | | | line search(for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| penalty_max | OT_REAL | 1.000e+30 | Maximal value |
+>| | | | for the penalty |
+>| | | | parameter (for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| penalty_update_ | OT_REAL | 10 | LIFENG WRITES |
+>| compl_tol | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| penalty_update_ | OT_REAL | 0.000 | Threshold for |
+>| infeasibility_t | | | infeasibility |
+>| ol | | | in penalty |
+>| | | | parameter |
+>| | | | update test. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| perturb_always_ | OT_STRING | no | Active |
+>| cd | | | permanent |
+>| | | | perturbation of |
+>| | | | constraint |
+>| | | | linearization. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| perturb_dec_fac | OT_REAL | 0.333 | Decrease factor |
+>| t | | | for x-s |
+>| | | | perturbation. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| perturb_inc_fac | OT_REAL | 8 | Increase factor |
+>| t | | | for x-s |
+>| | | | perturbation. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| perturb_inc_fac | OT_REAL | 100 | Increase factor |
+>| t_first | | | for x-s |
+>| | | | perturbation |
+>| | | | for very first |
+>| | | | perturbation. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| piecewisepenalt | OT_REAL | 0.000 | LIFENG WRITES |
+>| y_gamma_infeasi | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| piecewisepenalt | OT_REAL | 0.000 | LIFENG WRITES |
+>| y_gamma_obj | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| point_perturbat | OT_REAL | 10 | Maximal |
+>| ion_radius | | | perturbation of |
+>| | | | an evaluation |
+>| | | | point. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_frequency | OT_INTEGER | 1 | Determines at |
+>| _iter | | | which iteration |
+>| | | | frequency the |
+>| | | | summarizing |
+>| | | | iteration |
+>| | | | output line |
+>| | | | should be |
+>| | | | printed. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_frequency | OT_REAL | 0 | Determines at |
+>| _time | | | which time |
+>| | | | frequency the |
+>| | | | summarizing |
+>| | | | iteration |
+>| | | | output line |
+>| | | | should be |
+>| | | | printed. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_info_stri | OT_STRING | no | Enables |
+>| ng | | | printing of |
+>| | | | additional info |
+>| | | | string at end |
+>| | | | of iteration |
+>| | | | output. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_level | OT_INTEGER | 5 | Output |
+>| | | | verbosity |
+>| | | | level. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_options_d | OT_STRING | no | Switch to print |
+>| ocumentation | | | all algorithmic |
+>| | | | options. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_options_l | OT_STRING | no | Undocumented |
+>| atex_mode | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_time | OT_BOOLEAN | True | print |
+>| | | | information |
+>| | | | about execution |
+>| | | | time |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_timing_st | OT_STRING | no | Switch to print |
+>| atistics | | | timing |
+>| | | | statistics. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_user_opti | OT_STRING | no | Print all |
+>| ons | | | options set by |
+>| | | | the user. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quality_functio | OT_STRING | none | The balancing |
+>| n_balancing_ter | | | term included |
+>| m | | | in the quality |
+>| | | | function for |
+>| | | | centrality. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quality_functio | OT_STRING | none | The penalty |
+>| n_centrality | | | term for |
+>| | | | centrality that |
+>| | | | is included in |
+>| | | | quality |
+>| | | | function. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quality_functio | OT_INTEGER | 8 | Maximum number |
+>| n_max_section_s | | | of search steps |
+>| teps | | | during direct |
+>| | | | search |
+>| | | | procedure |
+>| | | | determining the |
+>| | | | optimal |
+>| | | | centering |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quality_functio | OT_STRING | 2-norm-squared | Norm used for |
+>| n_norm_type | | | components of |
+>| | | | the quality |
+>| | | | function. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quality_functio | OT_REAL | 0 | Tolerance for |
+>| n_section_qf_to | | | the golden |
+>| l | | | section search |
+>| | | | procedure |
+>| | | | determining the |
+>| | | | optimal |
+>| | | | centering |
+>| | | | parameter (in |
+>| | | | the function |
+>| | | | value space). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| quality_functio | OT_REAL | 0.010 | Tolerance for |
+>| n_section_sigma | | | the section |
+>| _tol | | | search |
+>| | | | procedure |
+>| | | | determining the |
+>| | | | optimal |
+>| | | | centering |
+>| | | | parameter (in |
+>| | | | sigma space). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| recalc_y | OT_STRING | no | Tells the |
+>| | | | algorithm to |
+>| | | | recalculate the |
+>| | | | equality and |
+>| | | | inequality |
+>| | | | multipliers as |
+>| | | | least square |
+>| | | | estimates. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| recalc_y_feas_t | OT_REAL | 0.000 | Feasibility |
+>| ol | | | threshold for |
+>| | | | recomputation |
+>| | | | of multipliers. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| replace_bounds | OT_STRING | no | Indicates if |
+>| | | | all variable |
+>| | | | bounds should |
+>| | | | be replaced by |
+>| | | | inequality |
+>| | | | constraints |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| required_infeas | OT_REAL | 0.900 | Required |
+>| ibility_reducti | | | reduction of |
+>| on | | | infeasibility |
+>| | | | before leaving |
+>| | | | restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| residual_improv | OT_REAL | 1.000 | Minimal |
+>| ement_factor | | | required |
+>| | | | reduction of |
+>| | | | residual test |
+>| | | | ratio in |
+>| | | | iterative |
+>| | | | refinement. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| residual_ratio_ | OT_REAL | 0.000 | Iterative |
+>| max | | | refinement |
+>| | | | tolerance (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| residual_ratio_ | OT_REAL | 0.000 | Threshold for |
+>| singular | | | declaring |
+>| | | | linear system |
+>| | | | singular after |
+>| | | | failed |
+>| | | | iterative |
+>| | | | refinement. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| resto_failure_f | OT_REAL | 0 | Threshold for |
+>| easibility_thre | | | primal |
+>| shold | | | infeasibility |
+>| | | | to declare |
+>| | | | failure of |
+>| | | | restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| resto_penalty_p | OT_REAL | 1000 | Penalty |
+>| arameter | | | parameter in |
+>| | | | the restoration |
+>| | | | phase objective |
+>| | | | function. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| resto_proximity | OT_REAL | 1 | Weighting |
+>| _weight | | | factor for the |
+>| | | | proximity term |
+>| | | | in restoration |
+>| | | | phase |
+>| | | | objective. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| rho | OT_REAL | 0.100 | Value in |
+>| | | | penalty |
+>| | | | parameter |
+>| | | | update formula. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| s_max | OT_REAL | 100 | Scaling |
+>| | | | threshold for |
+>| | | | the NLP error. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| s_phi | OT_REAL | 2.300 | Exponent for |
+>| | | | linear barrier |
+>| | | | function model |
+>| | | | in the |
+>| | | | switching rule. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| s_theta | OT_REAL | 1.100 | Exponent for |
+>| | | | current |
+>| | | | constraint |
+>| | | | violation in |
+>| | | | the switching |
+>| | | | rule. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| sb | OT_STRING | no | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| sigma_max | OT_REAL | 100 | Maximum value |
+>| | | | of the |
+>| | | | centering |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| sigma_min | OT_REAL | 0.000 | Minimum value |
+>| | | | of the |
+>| | | | centering |
+>| | | | parameter. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| skip_corr_if_ne | OT_STRING | yes | Skip the |
+>| g_curv | | | corrector step |
+>| | | | in negative |
+>| | | | curvature |
+>| | | | iteration |
+>| | | | (unsupported!). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| skip_corr_in_mo | OT_STRING | yes | Skip the |
+>| notone_mode | | | corrector step |
+>| | | | during monotone |
+>| | | | barrier |
+>| | | | parameter mode |
+>| | | | (unsupported!). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| skip_finalize_s | OT_STRING | no | Indicates if |
+>| olution_call | | | call to NLP::Fi |
+>| | | | nalizeSolution |
+>| | | | after |
+>| | | | optimization |
+>| | | | should be |
+>| | | | suppressed (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| slack_bound_fra | OT_REAL | 0.010 | Desired minimum |
+>| c | | | relative |
+>| | | | distance from |
+>| | | | the initial |
+>| | | | slack to bound. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| slack_bound_pus | OT_REAL | 0.010 | Desired minimum |
+>| h | | | absolute |
+>| | | | distance from |
+>| | | | the initial |
+>| | | | slack to bound. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| slack_move | OT_REAL | 0.000 | Correction size |
+>| | | | for very small |
+>| | | | slacks. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| soft_resto_pder | OT_REAL | 1.000 | Required |
+>| ror_reduction_f | | | reduction in |
+>| actor | | | primal-dual |
+>| | | | error in the |
+>| | | | soft |
+>| | | | restoration |
+>| | | | phase. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| start_with_rest | OT_STRING | no | Tells algorithm |
+>| o | | | to switch to |
+>| | | | restoration |
+>| | | | phase in first |
+>| | | | iteration. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| suppress_all_ou | OT_STRING | no | Undocumented |
+>| tput | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tau_min | OT_REAL | 0.990 | Lower bound on |
+>| | | | fraction-to- |
+>| | | | the-boundary |
+>| | | | parameter tau. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| theta_max_fact | OT_REAL | 10000 | Determines |
+>| | | | upper bound for |
+>| | | | constraint |
+>| | | | violation in |
+>| | | | the filter. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| theta_min | OT_REAL | 0.000 | LIFENG WRITES |
+>| | | | THIS. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| theta_min_fact | OT_REAL | 0.000 | Determines |
+>| | | | constraint |
+>| | | | violation |
+>| | | | threshold in |
+>| | | | the switching |
+>| | | | rule. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tiny_step_tol | OT_REAL | 0.000 | Tolerance for |
+>| | | | detecting |
+>| | | | numerically |
+>| | | | insignificant |
+>| | | | steps. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tiny_step_y_tol | OT_REAL | 0.010 | Tolerance for |
+>| | | | quitting |
+>| | | | because of |
+>| | | | numerically |
+>| | | | insignificant |
+>| | | | steps. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol | OT_REAL | 0.000 | Desired |
+>| | | | convergence |
+>| | | | tolerance |
+>| | | | (relative). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| var_integer_md | OT_DICTIONARY | None | Integer |
+>| | | | metadata (a |
+>| | | | dictionary with |
+>| | | | lists of |
+>| | | | integers) about |
+>| | | | variables to be |
+>| | | | passed to IPOPT |
+>+-----------------+-----------------+-----------------+-----------------+
+>| var_numeric_md | OT_DICTIONARY | None | Numeric |
+>| | | | metadata (a |
+>| | | | dictionary with |
+>| | | | lists of reals) |
+>| | | | about variables |
+>| | | | to be passed to |
+>| | | | IPOPT |
+>+-----------------+-----------------+-----------------+-----------------+
+>| var_string_md | OT_DICTIONARY | None | String metadata |
+>| | | | (a dictionary |
+>| | | | with lists of |
+>| | | | strings) about |
+>| | | | variables to be |
+>| | | | passed to IPOPT |
+>+-----------------+-----------------+-----------------+-----------------+
+>| vartheta | OT_REAL | 0.500 | a parameter |
+>| | | | used to check |
+>| | | | if the fast |
+>| | | | direction can |
+>| | | | be used asthe |
+>| | | | line search |
+>| | | | direction (for |
+>| | | | Chen-Goldfarb |
+>| | | | line search). |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_boun | OT_REAL | 0.001 | same as |
+>| d_frac | | | bound_frac for |
+>| | | | the regular |
+>| | | | initializer. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_boun | OT_REAL | 0.001 | same as |
+>| d_push | | | bound_push for |
+>| | | | the regular |
+>| | | | initializer. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_enti | OT_STRING | no | Tells algorithm |
+>| re_iterate | | | whether to use |
+>| | | | the GetWarmStar |
+>| | | | tIterate method |
+>| | | | in the NLP. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_init | OT_STRING | no | Warm-start for |
+>| _point | | | initial point |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_mult | OT_REAL | 0.001 | same as |
+>| _bound_push | | | mult_bound_push |
+>| | | | for the regular |
+>| | | | initializer. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_mult | OT_REAL | 1000000 | Maximum initial |
+>| _init_max | | | value for the |
+>| | | | equality |
+>| | | | multipliers. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_same | OT_STRING | no | Indicates |
+>| _structure | | | whether a |
+>| | | | problem with a |
+>| | | | structure |
+>| | | | identical to |
+>| | | | the previous |
+>| | | | one is to be |
+>| | | | solved. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_slac | OT_REAL | 0.001 | same as slack_b |
+>| k_bound_frac | | | ound_frac for |
+>| | | | the regular |
+>| | | | initializer. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_slac | OT_REAL | 0.001 | same as slack_b |
+>| k_bound_push | | | ound_push for |
+>| | | | the regular |
+>| | | | initializer. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start_targ | OT_REAL | 0 | Unsupported! |
+>| et_mu | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| watchdog_shorte | OT_INTEGER | 10 | Number of |
+>| ned_iter_trigge | | | shortened |
+>| r | | | iterations that |
+>| | | | trigger the |
+>| | | | watchdog. (see |
+>| | | | IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| watchdog_trial_ | OT_INTEGER | 3 | Maximum number |
+>| iter_max | | | of watchdog |
+>| | | | iterations. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| wsmp_iterative | OT_STRING | no | Switches to |
+>| | | | iterative |
+>| | | | solver in WSMP. |
+>| | | | (see IPOPT |
+>| | | | documentation) |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-------------+
+>| Id |
+>+=============+
+>| eval_f |
+>+-------------+
+>| eval_g |
+>+-------------+
+>| eval_grad_f |
+>+-------------+
+>| eval_h |
+>+-------------+
+>| eval_jac_g |
+>+-------------+
+>
+>>List of available stats
+>
+>+--------------------+
+>| Id |
+>+====================+
+>| con_integer_md |
+>+--------------------+
+>| con_numeric_md |
+>+--------------------+
+>| con_string_md |
+>+--------------------+
+>| iter_count |
+>+--------------------+
+>| iteration |
+>+--------------------+
+>| iterations |
+>+--------------------+
+>| n_eval_f |
+>+--------------------+
+>| n_eval_g |
+>+--------------------+
+>| n_eval_grad_f |
+>+--------------------+
+>| n_eval_h |
+>+--------------------+
+>| n_eval_jac_g |
+>+--------------------+
+>| return_status |
+>+--------------------+
+>| t_callback_fun |
+>+--------------------+
+>| t_callback_prepare |
+>+--------------------+
+>| t_eval_f |
+>+--------------------+
+>| t_eval_g |
+>+--------------------+
+>| t_eval_grad_f |
+>+--------------------+
+>| t_eval_h |
+>+--------------------+
+>| t_eval_jac_g |
+>+--------------------+
+>| t_mainloop |
+>+--------------------+
+>| var_integer_md |
+>+--------------------+
+>| var_numeric_md |
+>+--------------------+
+>| var_string_md |
+>+--------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>knitro
+>------
+>
+>
+>
+>KNITRO interface
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| BarRule | OT_INTEGER | 0 | Barrier Rule |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Debug | OT_INTEGER | 0 | Debug level |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Delta | OT_REAL | 1 | Initial region |
+>| | | | scaling factor |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FeasModeTol | OT_REAL | 0.000 | Feasible mode |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FeasTol | OT_REAL | 0.000 | Feasible |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FeasTolAbs | OT_REAL | 0 | Absolute |
+>| | | | feasible |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Feasible | OT_BOOLEAN | 1 | Allow |
+>| | | | infeasible |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| GradOpt | OT_INTEGER | 1 | Gradient |
+>| | | | calculation |
+>| | | | method |
+>+-----------------+-----------------+-----------------+-----------------+
+>| HessOpt | OT_INTEGER | 1 | Hessian |
+>| | | | calculation |
+>| | | | method |
+>+-----------------+-----------------+-----------------+-----------------+
+>| HonorBnds | OT_BOOLEAN | 0 | Enforce bounds |
+>+-----------------+-----------------+-----------------+-----------------+
+>| InitPt | OT_BOOLEAN | 0 | Use initial |
+>| | | | point strategy |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LmSize | OT_INTEGER | 10 | Memory pairsize |
+>| | | | limit |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LpSolver | OT_BOOLEAN | 0 | Use LpSolver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxCgIt | OT_INTEGER | 0 | Maximum |
+>| | | | conjugate |
+>| | | | gradient |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxIt | OT_INTEGER | 10000 | Iteration limit |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Mu | OT_REAL | 0.100 | Initial barrier |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Multistart | OT_BOOLEAN | 0 | Use multistart |
+>+-----------------+-----------------+-----------------+-----------------+
+>| NewPoint | OT_BOOLEAN | 0 | Select new- |
+>| | | | point feature |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ObjRange | OT_REAL | 1.000e+20 | Maximum |
+>| | | | objective value |
+>+-----------------+-----------------+-----------------+-----------------+
+>| OptTol | OT_REAL | 0.000 | Relative |
+>| | | | optimality |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| OptTolAbs | OT_REAL | 0 | Absolute |
+>| | | | optimality |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| OutLev | OT_INTEGER | 2 | Log output |
+>| | | | level |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Pivot | OT_REAL | 0.000 | Initial pivot |
+>| | | | threshold |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Scale | OT_BOOLEAN | 1 | Perform scaling |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ShiftInit | OT_BOOLEAN | 1 | Interior-point |
+>| | | | shifting |
+>| | | | initial point |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Soc | OT_INTEGER | 1 | Second order |
+>| | | | correction |
+>+-----------------+-----------------+-----------------+-----------------+
+>| XTol | OT_REAL | 0.000 | Relative |
+>| | | | solution change |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| contype | OT_INTEGERVECTO | | |
+>| | R | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-------------+
+>| Id |
+>+=============+
+>| eval_f |
+>+-------------+
+>| eval_g |
+>+-------------+
+>| eval_grad_f |
+>+-------------+
+>| eval_h |
+>+-------------+
+>| eval_jac_g |
+>+-------------+
+>
+>>List of available stats
+>
+>+---------------+
+>| Id |
+>+===============+
+>| return_status |
+>+---------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>snopt
+>-----
+>
+>
+>
+>SNOPT interface
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| Backup basis | OT_INTEGER | None | 0 * output |
+>| file | | | extra basis map |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Central | OT_REAL | None | 6.7e-5 * ( |
+>| difference | | | Function |
+>| interval | | | precision)^1/3 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Check frequency | OT_INTEGER | None | 60 * test row |
+>| | | | residuals kAx |
+>| | | | sk |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Crash option | OT_INTEGER | None | 3 * first basis |
+>| | | | is essentially |
+>| | | | triangular |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Crash tolerance | OT_REAL | None | 0.100 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Debug level | OT_INTEGER | None | 0 * for |
+>| | | | developers |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Derivative | OT_INTEGER | None | 3 |
+>| level | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Difference | OT_REAL | None | 5.5e-7 * ( |
+>| interval | | | Function |
+>| | | | precision)^1/2 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Dump file | OT_INTEGER | None | 0 * output Load |
+>| | | | data |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Elastic weight | OT_REAL | None | 1.0e+4 * used |
+>| | | | only during |
+>| | | | elastic mode |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Expand | OT_INTEGER | None | 10000 * for |
+>| frequency | | | anti-cycling |
+>| | | | procedure |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Factorization | OT_INTEGER | None | 50 * 100 for |
+>| frequency | | | LPs |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Function | OT_REAL | None | 3.0e-13 * e^0.8 |
+>| precision | | | (almost full |
+>| | | | accuracy) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Hessian | OT_STRING | None | full memory * |
+>| | | | default if n1 |
+>| | | | 75 limited |
+>| | | | memory * |
+>| | | | default if n1 > |
+>| | | | 75 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Hessian flush | OT_INTEGER | None | 999999 * no |
+>| | | | flushing |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Hessian | OT_INTEGER | None | 999999 * for |
+>| frequency | | | full Hessian |
+>| | | | (never reset) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Hessian updates | OT_INTEGER | None | 10 * for |
+>| | | | limited memory |
+>| | | | Hessian |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Insert file | OT_INTEGER | None | 0 * input in |
+>| | | | industry format |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Iterations | OT_INTEGER | None | 10000 * or 20m |
+>| limit | | | if that is more |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LU | OT_STRING | None | LU partial |
+>| | | | pivoting * |
+>| | | | default |
+>| | | | threshold |
+>| | | | pivoting |
+>| | | | strategy LU |
+>| | | | rook pivoting * |
+>| | | | threshold rook |
+>| | | | pivoting LU |
+>| | | | complete |
+>| | | | pivoting * |
+>| | | | threshold |
+>| | | | complete |
+>| | | | pivoting |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LU factor | OT_REAL | None | 3.99 * for NP |
+>| tolerance | | | (100.0 for LP) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LU singularity | OT_REAL | None | 0.000 |
+>| tolerance | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LU update | OT_REAL | None | 3.99 * for NP ( |
+>| tolerance | | | 10.0 for LP) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Linesearch | OT_REAL | None | 0.9 * smaller |
+>| tolerance | | | for more |
+>| | | | accurate search |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Load file | OT_INTEGER | None | 0 * input names |
+>| | | | and values |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Major | OT_REAL | None | 1.0e-6 * target |
+>| feasibility | | | nonlinear |
+>| tolerance | | | constraint |
+>| | | | violation |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Major | OT_INTEGER | None | 1000 * or m if |
+>| iterations | | | that is more |
+>| limit | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Major | OT_REAL | None | 1.0e-6 * target |
+>| optimality | | | complementarity |
+>| tolerance | | | gap |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Major print | OT_INTEGER | None | 1 * 1-line |
+>| level | | | major iteration |
+>| | | | log |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Major step | OT_REAL | None | 2 |
+>| limit | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Minor | OT_REAL | None | 1.0e-6 * for |
+>| feasibility | | | satisfying the |
+>| tolerance | | | QP bounds |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Minor | OT_INTEGER | None | 500 * or 3m if |
+>| iterations | | | that is more |
+>| limit | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Minor print | OT_INTEGER | None | 1 * 1-line |
+>| level | | | minor iteration |
+>| | | | log |
+>+-----------------+-----------------+-----------------+-----------------+
+>| New basis file | OT_INTEGER | None | 0 * output |
+>| | | | basis map |
+>+-----------------+-----------------+-----------------+-----------------+
+>| New superbasics | OT_INTEGER | None | 99 * controls |
+>| limit | | | early |
+>| | | | termination of |
+>| | | | QPs |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Old basis file | OT_INTEGER | None | 0 * input basis |
+>| | | | map |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Partial price | OT_INTEGER | None | 1 * 10 for |
+>| | | | large LPs |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Penalty | OT_REAL | None | 0.0 * initial |
+>| parameter | | | penalty |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Pivot tolerance | OT_REAL | None | 3.7e-11 * e^2/3 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Print frequency | OT_INTEGER | None | 100 * minor |
+>| | | | iterations log |
+>| | | | on Print file |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Proximal point | OT_INTEGER | None | 1 * satisfies |
+>| method | | | linear |
+>| | | | constraints |
+>| | | | near x0 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Punch file | OT_INTEGER | None | 0 * output |
+>| | | | Insert data |
+>+-----------------+-----------------+-----------------+-----------------+
+>| QPSolver | OT_STRING | None | Cholesky * |
+>| | | | default |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Reduced Hessian | OT_INTEGER | None | 2000 * or |
+>| dimension | | | Superbasics |
+>| | | | limit if that |
+>| | | | is less |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Save frequency | OT_INTEGER | None | 100 * save |
+>| | | | basis map |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Scale option | OT_INTEGER | None | 1 * linear |
+>| | | | constraints and |
+>| | | | variables |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Scale tolerance | OT_REAL | None | 0.900 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Solution | OT_STRING | None | Yes * on the |
+>| | | | Print file |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Solution file | OT_INTEGER | None | 0 * different |
+>| | | | from printed |
+>| | | | solution |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Sticky | OT_STRING | None | No * Yes makes |
+>| parameters | | | parameter |
+>| | | | values persist |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Summary | OT_INTEGER | None | 100 * minor |
+>| frequency | | | iterations log |
+>| | | | on Summary file |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Superbasics | OT_INTEGER | None | n1 + 1 * n1 = |
+>| limit | | | number of |
+>| | | | nonlinear |
+>| | | | variables |
+>+-----------------+-----------------+-----------------+-----------------+
+>| System | OT_STRING | None | No * Yes prints |
+>| information | | | more system |
+>| | | | information |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Timing level | OT_INTEGER | None | 3 * print cpu |
+>| | | | times |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Unbounded | OT_REAL | None | 1.000e+15 |
+>| objective | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Unbounded step | OT_REAL | None | 1.000e+18 |
+>| size | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Verify level | OT_INTEGER | None | 0 * cheap check |
+>| | | | on gradients |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Violation limit | OT_REAL | None | 10.0 * unscaled |
+>| | | | constraint |
+>| | | | violation limit |
+>+-----------------+-----------------+-----------------+-----------------+
+>| detect_linear | OT_BOOLEAN | True | Make an effort |
+>| | | | to treat linear |
+>| | | | constraints and |
+>| | | | linear |
+>| | | | variables |
+>| | | | specially. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print file | OT_STRING | None | n/a |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_time | OT_BOOLEAN | True | print |
+>| | | | information |
+>| | | | about execution |
+>| | | | time |
+>+-----------------+-----------------+-----------------+-----------------+
+>| specs file | OT_STRING | None | n/a |
+>+-----------------+-----------------+-----------------+-----------------+
+>| start | OT_STRING | Cold | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| summary | OT_BOOLEAN | True | n/a |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-----------+
+>| Id |
+>+===========+
+>| eval_nlp |
+>+-----------+
+>| setup_nlp |
+>+-----------+
+>
+>>List of available stats
+>
+>+----------------+
+>| Id |
+>+================+
+>| iter_count |
+>+----------------+
+>| iterations |
+>+----------------+
+>| n_callback_fun |
+>+----------------+
+>| n_eval_grad_f |
+>+----------------+
+>| n_eval_jac_g |
+>+----------------+
+>| return_status |
+>+----------------+
+>| t_callback_fun |
+>+----------------+
+>| t_eval_grad_f |
+>+----------------+
+>| t_eval_jac_g |
+>+----------------+
+>| t_mainloop |
+>+----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>worhp
+>-----
+>
+>
+>
+>WORHP interface
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| AcceptTolFeas | OT_REAL | 0.001 | Tolerance for |
+>| | | | acceptable |
+>| | | | feasibility |
+>+-----------------+-----------------+-----------------+-----------------+
+>| AcceptTolOpti | OT_REAL | 0.001 | Tolerance for |
+>| | | | acceptable |
+>| | | | optimality |
+>+-----------------+-----------------+-----------------+-----------------+
+>| AlphaMinConst | OT_BOOLEAN | False | Use a constant |
+>| | | | lower bound on |
+>| | | | Armijo stepsize |
+>| | | | in Filter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Ares | OT_INTEGERVECTO | [42, 41, 42, | Armijo recovery |
+>| | R | 43, 44, 41, 50] | strategies. |
+>| | | | Vector of size |
+>| | | | 7 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ArmijoBeta | OT_REAL | 0.712 | Trial stepsize |
+>| | | | decrease factor |
+>| | | | for Armijo rule |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ArmijoMaxAlpha | OT_REAL | 1 | Initial alpha |
+>| | | | for Armijo rule |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ArmijoMinAlpha | OT_REAL | 0.000 | Lower bound on |
+>| | | | alpha for |
+>| | | | Armijo rule |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ArmijoMinAlphaR | OT_REAL | 0.000 | Lower bound on |
+>| ec | | | alpha for |
+>| | | | Armijo rule |
+>| | | | during recovery |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ArmijoSigma | OT_REAL | 0.005 | Scale factor |
+>| | | | for linearised |
+>| | | | descent check |
+>| | | | in Armijo rule |
+>+-----------------+-----------------+-----------------+-----------------+
+>| AutoQPRecovery | OT_BOOLEAN | True | Enable |
+>| | | | automatic QP |
+>| | | | recovery |
+>+-----------------+-----------------+-----------------+-----------------+
+>| BFGSmaxblockSiz | OT_INTEGER | 300 | Block size |
+>| e | | | parameter used |
+>| | | | by certain BFGS |
+>| | | | methods |
+>+-----------------+-----------------+-----------------+-----------------+
+>| BFGSmethod | OT_INTEGER | 0 | Choose BFGS |
+>| | | | method (0: |
+>| | | | dense, 1-3: |
+>| | | | block, 100+: |
+>| | | | sparse) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| BFGSminblockSiz | OT_INTEGER | 300 | Block size |
+>| e | | | parameter used |
+>| | | | by certain BFGS |
+>| | | | methods |
+>+-----------------+-----------------+-----------------+-----------------+
+>| BFGSrestart | OT_INTEGER | 50 | Restart BFGS |
+>| | | | update after |
+>| | | | this many |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| BettsFactor | OT_REAL | 2.100 | Update factor |
+>| | | | for Betts' |
+>| | | | Hessian |
+>| | | | regularisation |
+>+-----------------+-----------------+-----------------+-----------------+
+>| BettsPoint | OT_REAL | 1 | Smallest |
+>| | | | eigenvalue of |
+>| | | | the regularised |
+>| | | | Hessian |
+>+-----------------+-----------------+-----------------+-----------------+
+>| BoundTolFac | OT_REAL | 1000 | Factor in |
+>| | | | determining |
+>| | | | active |
+>| | | | constraints by |
+>| | | | KKT |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CheckFJ | OT_REAL | 1.000e+12 | Upper bound |
+>| | | | used by Fritz- |
+>| | | | John heuristic |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CheckStructureD | OT_BOOLEAN | True | Enable |
+>| F | | | structural |
+>| | | | checking of DF |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CheckStructureD | OT_BOOLEAN | True | Enable |
+>| G | | | structural |
+>| | | | checking of DG |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CheckStructureH | OT_BOOLEAN | True | Enable |
+>| M | | | structural |
+>| | | | checking of HM |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepBettsSum | OT_REAL | 0.500 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepConStop | OT_REAL | 0.000 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepConvio | OT_REAL | 1 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepMaxIter | OT_INTEGER | 50 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepMethod | OT_INTEGER | 0 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepMode | OT_INTEGER | 1 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepPFactor | OT_REAL | 1 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepPMax | OT_REAL | 1000000 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CorStepRecovery | OT_BOOLEAN | False | (experimental) |
+>| DX | | | |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CurvBCond | OT_REAL | 0.020 | Block BFGS |
+>| | | | curvature |
+>| | | | condition bound |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CurvBFac | OT_REAL | 0.300 | Block BFGS |
+>| | | | curvature |
+>| | | | condition |
+>| | | | regularisation |
+>| | | | factor |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CurvCond | OT_REAL | 0.020 | BFGS Curvature |
+>| | | | condition bound |
+>+-----------------+-----------------+-----------------+-----------------+
+>| CurvFac | OT_REAL | 0.300 | BFGS curvature |
+>| | | | condition |
+>| | | | regularisation |
+>| | | | factor |
+>+-----------------+-----------------+-----------------+-----------------+
+>| DebugMarker05 | OT_INTEGER | 42 | Debug marker. |
+>| | | | Used to find |
+>| | | | memory alignmen |
+>| | | | t/padding |
+>| | | | issues |
+>+-----------------+-----------------+-----------------+-----------------+
+>| DebugMarker06 | OT_INTEGER | 42 | Debug marker. |
+>| | | | Used to find |
+>| | | | memory alignmen |
+>| | | | t/padding |
+>| | | | issues |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FGtogether | OT_BOOLEAN | False | F and G cannot |
+>| | | | be evaluated |
+>| | | | separately |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FJandND | OT_BOOLEAN | False | Enable Fritz- |
+>| | | | John and non- |
+>| | | | differentiable |
+>| | | | check |
+>| | | | heuristics |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FeasibleDual | OT_BOOLEAN | False | Activate dual |
+>| | | | feasibility |
+>| | | | mode |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FeasibleInit | OT_BOOLEAN | False | Activate |
+>| | | | initial |
+>| | | | feasibility |
+>| | | | mode |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FeasibleInitTol | OT_REAL | 0.001 | Feasibility |
+>| | | | tolerance for |
+>| | | | no-objective |
+>| | | | feasible mode |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FeasibleOnly | OT_BOOLEAN | False | Activate |
+>| | | | feasible-only |
+>| | | | mode |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FidifEps | OT_REAL | 0.000 | Finite |
+>| | | | difference |
+>| | | | perturbation |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FidifHM | OT_BOOLEAN | False | Approximate |
+>| | | | Hessian by |
+>| | | | finite |
+>| | | | differences |
+>| | | | (otherwise |
+>| | | | BFGS) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FilterBisecAlph | OT_BOOLEAN | True | Filter |
+>| a | | | heuristic to |
+>| | | | save Armijo |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FilterGammaCV | OT_REAL | 0.000 | Constraint |
+>| | | | violation |
+>| | | | decrease factor |
+>| | | | in Filter |
+>| | | | acceptance |
+>| | | | check |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FilterGammaF | OT_REAL | 0.000 | Objective |
+>| | | | decrease factor |
+>| | | | in Filter |
+>| | | | acceptance |
+>| | | | check |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FilterIntersecA | OT_BOOLEAN | True | Filter |
+>| lpha | | | heuristic to |
+>| | | | save Armijo |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FirstDifCentral | OT_BOOLEAN | True | Use central |
+>| | | | finite |
+>| | | | difference |
+>| | | | quotient for |
+>| | | | first |
+>| | | | derivatives |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FocusOnFeas | OT_BOOLEAN | True | Enable Focus- |
+>| | | | on-Feasibility |
+>| | | | mode |
+>+-----------------+-----------------+-----------------+-----------------+
+>| FocusOnFeasFact | OT_REAL | 1.360 | Factor in |
+>| or | | | Focus-on- |
+>| | | | Feasibility |
+>| | | | mode |
+>+-----------------+-----------------+-----------------+-----------------+
+>| GammaAlpha | OT_REAL | 0.050 | Safety factor |
+>| | | | for alphamin |
+>| | | | calculation by |
+>| | | | Filter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| GroupMethod | OT_INTEGER | 1 | Select method |
+>| | | | to determine |
+>| | | | graph colouring |
+>| | | | groups |
+>+-----------------+-----------------+-----------------+-----------------+
+>| IgnoreFilterCri | OT_BOOLEAN | False | Activate |
+>| t | | | accelerating |
+>| | | | heuristics for |
+>| | | | Filter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| IncBettsTau | OT_REAL | 2 | Increase factor |
+>| | | | for Betts' |
+>| | | | update |
+>| | | | dampening term |
+>+-----------------+-----------------+-----------------+-----------------+
+>| IncBettsTauMore | OT_REAL | 100 | Larger increase |
+>| | | | factor for |
+>| | | | Betts' update |
+>| | | | dampening term |
+>+-----------------+-----------------+-----------------+-----------------+
+>| IncreaseIWS | OT_REAL | 1 | Increase factor |
+>| | | | for estimated |
+>| | | | integer |
+>| | | | workspace |
+>| | | | requirement |
+>+-----------------+-----------------+-----------------+-----------------+
+>| IncreaseRWS | OT_REAL | 1 | Increase factor |
+>| | | | for estimated |
+>| | | | real workspace |
+>| | | | requirement |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Infty | OT_REAL | 1.000e+20 | Upper bound for |
+>| | | | numbers to be |
+>| | | | regarded as |
+>| | | | finite |
+>+-----------------+-----------------+-----------------+-----------------+
+>| InftyUnbounded | OT_REAL | 1.000e+20 | Tolerance for |
+>| | | | unboundedness |
+>| | | | detection |
+>| | | | heuristic |
+>+-----------------+-----------------+-----------------+-----------------+
+>| InitialLMest | OT_BOOLEAN | True | Enable initial |
+>| | | | Lagrange |
+>| | | | multiplier |
+>| | | | estimate |
+>+-----------------+-----------------+-----------------+-----------------+
+>| KeepAcceptableS | OT_BOOLEAN | True | Save acceptable |
+>| ol | | | solutions as |
+>| | | | fallback |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LMestQPipComTol | OT_REAL | 0.003 | IP |
+>| | | | complementarity |
+>| | | | tolerance in |
+>| | | | initial |
+>| | | | multiplier |
+>| | | | estimate |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LMestQPipResTol | OT_REAL | 1 | IP residual |
+>| | | | tolerance in |
+>| | | | initial |
+>| | | | multiplier |
+>| | | | estimate |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LinMult | OT_BOOLEAN | False | Control |
+>| | | | Lagrange |
+>| | | | multiplier |
+>| | | | update |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LogLevel | OT_INTEGER | 0 | Enable XML |
+>| | | | logfiles and |
+>| | | | writing |
+>| | | | interval |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LogResult | OT_INTEGER | 0 | Enable XML |
+>| | | | result logging |
+>| | | | and detail |
+>| | | | level |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LowPassAlphaF | OT_REAL | 0.950 | Lowpass-filter |
+>| | | | update factor |
+>| | | | for objective |
+>| | | | values |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LowPassAlphaG | OT_REAL | 0.950 | Lowpass-filter |
+>| | | | update factor |
+>| | | | for constraint |
+>| | | | values |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LowPassAlphaMer | OT_REAL | 0.100 | Lowpass-filter |
+>| it | | | update factor |
+>| | | | for merit |
+>| | | | function values |
+>+-----------------+-----------------+-----------------+-----------------+
+>| LowPassFilter | OT_BOOLEAN | True | Enable lowpass- |
+>| | | | filter |
+>| | | | termination |
+>| | | | criterion |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MAPivotThreshol | OT_REAL | 0.000 | Pivoting |
+>| d | | | tolerance for |
+>| | | | MA solvers |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MatrixCC | OT_BOOLEAN | False | Not to be |
+>| | | | included into a |
+>| | | | parameter file! |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxCalls | OT_INTEGER | 2.147e+09 | Upper bound to |
+>| | | | Reverse |
+>| | | | Communication |
+>| | | | calls |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxForce | OT_INTEGER | 1000 | Maximum number |
+>| | | | of Force |
+>| | | | recovery |
+>| | | | strategy steps |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxGPart | OT_INTEGER | 1 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxIter | OT_INTEGER | 500 | Upper bound on |
+>| | | | major |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxLScounter | OT_INTEGER | 3 | Control |
+>| | | | activation of |
+>| | | | Filter |
+>| | | | acceleration |
+>| | | | heuristics |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MaxNorm | OT_BOOLEAN | True | Select max-norm |
+>| | | | instead of |
+>| | | | 1-norm in |
+>| | | | Filter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MeritFunction | OT_INTEGER | 4 | Select merit |
+>| | | | function and |
+>| | | | penalty update |
+>| | | | [0, 3..5] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MeritGradTol | OT_REAL | 0.000 | Threshold of |
+>| | | | meritfunction |
+>| | | | gradient for |
+>| | | | increasing |
+>| | | | Hessian |
+>| | | | regularisation |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MinBettsTau | OT_REAL | 0.000 | Lower bound for |
+>| | | | Betts' update |
+>| | | | dampening term |
+>+-----------------+-----------------+-----------------+-----------------+
+>| MoreRelax | OT_BOOLEAN | False | Introduce one |
+>| | | | relaxation |
+>| | | | variable for |
+>| | | | every |
+>| | | | constraint |
+>+-----------------+-----------------+-----------------+-----------------+
+>| NLPmethod | OT_INTEGER | 1 | Select (1) |
+>| | | | Meritfunction |
+>| | | | or (3) Filter |
+>| | | | globalisation |
+>+-----------------+-----------------+-----------------+-----------------+
+>| NLPprint | OT_INTEGER | 2 | NLP print level |
+>| | | | [-1..4] |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PairMethod | OT_INTEGER | 1 | Select method |
+>| | | | to determine |
+>| | | | graph colouring |
+>| | | | pairgroups |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PenUpdEpsBar | OT_REAL | 0.900 | Penalty update |
+>| | | | parameter |
+>| | | | factor for |
+>| | | | MeritFunction = |
+>| | | | 3 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PenUpdEpsKFac | OT_REAL | 2 | Penalty update |
+>| | | | parameter |
+>| | | | factor for |
+>| | | | MeritFunction = |
+>| | | | 4 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PenUpdEpsKSeque | OT_INTEGER | 2 | Penalty update |
+>| nce | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PenUpdMaxDeltaK | OT_REAL | 11 | Max penalty for |
+>| | | | MeritFunction = |
+>| | | | 4 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PenUpdMaxFac | OT_REAL | 100000000 | Max factor for |
+>| | | | increasing |
+>| | | | penalty for |
+>| | | | MeritFunction = |
+>| | | | 4 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PenUpdRBar | OT_REAL | 2 | Penalty update |
+>| | | | parameter for |
+>| | | | MeritFunction = |
+>| | | | 3 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PrecisionF | OT_REAL | 0.000 | (currently |
+>| | | | unused) |
+>| | | | Relative |
+>| | | | precision of |
+>| | | | objective |
+>+-----------------+-----------------+-----------------+-----------------+
+>| PrecisionG | OT_REAL | 0.000 | (currently |
+>| | | | unused) |
+>| | | | Relative |
+>| | | | precision of |
+>| | | | constraints |
+>+-----------------+-----------------+-----------------+-----------------+
+>| QPscaleParam | OT_REAL | 0 | (currently |
+>| | | | unused) Scaling |
+>| | | | factor for QP |
+>+-----------------+-----------------+-----------------+-----------------+
+>| QuadraticProble | OT_BOOLEAN | False | Not to be |
+>| m | | | included into a |
+>| | | | parameter file! |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ReduceBettsTau | OT_REAL | 0.300 | Decrease factor |
+>| | | | for Betts' |
+>| | | | update |
+>| | | | dampening term |
+>+-----------------+-----------------+-----------------+-----------------+
+>| RegStrategy | OT_INTEGER | 1 | Select Hessian |
+>| | | | regularisation |
+>| | | | strategy in |
+>| | | | Filter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ReinitFilter | OT_BOOLEAN | False | Enables Filter- |
+>| | | | reinitialisatio |
+>| | | | n accelerating |
+>| | | | heuristic |
+>+-----------------+-----------------+-----------------+-----------------+
+>| RelaxMaxDelta | OT_REAL | 0.920 | Upper bound for |
+>| | | | accepting the |
+>| | | | constraint |
+>| | | | relaxation |
+>| | | | variable |
+>+-----------------+-----------------+-----------------+-----------------+
+>| RelaxMaxPen | OT_REAL | 50000000 | Upper bound on |
+>| | | | the constraint |
+>| | | | relaxation |
+>| | | | penalty |
+>+-----------------+-----------------+-----------------+-----------------+
+>| RelaxRho | OT_REAL | 6 | Update factor |
+>| | | | for the |
+>| | | | constraint |
+>| | | | relaxation |
+>| | | | penalty |
+>+-----------------+-----------------+-----------------+-----------------+
+>| RelaxStart | OT_REAL | 1 | Initial value |
+>| | | | of the |
+>| | | | constraint |
+>| | | | relaxation |
+>| | | | penalty |
+>+-----------------+-----------------+-----------------+-----------------+
+>| RestUntilFeas | OT_BOOLEAN | False | Do restoration |
+>| | | | until a |
+>| | | | feasible |
+>| | | | solution is |
+>| | | | found |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ScaleConIter | OT_BOOLEAN | False | Scale |
+>| | | | constraints in |
+>| | | | every iteration |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ScaleFacObj | OT_REAL | 10 | Value to scale |
+>| | | | large objective |
+>| | | | functions to |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ScaleFacQP | OT_REAL | 10 | Upper bound on |
+>| | | | resulting |
+>| | | | matrix norm for |
+>| | | | QP scaling |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ScaledFD | OT_BOOLEAN | True | Use a scaled |
+>| | | | perturbation |
+>| | | | for finite |
+>| | | | differences |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ScaledKKT | OT_BOOLEAN | True | Scale KKT |
+>| | | | conditions |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ScaledObj | OT_BOOLEAN | True | Scale the |
+>| | | | objective |
+>| | | | function |
+>+-----------------+-----------------+-----------------+-----------------+
+>| ScaledQP | OT_BOOLEAN | True | Scale some |
+>| | | | matrices handed |
+>| | | | to the QP |
+>+-----------------+-----------------+-----------------+-----------------+
+>| StartBettsTau | OT_REAL | 0.100 | Initial value |
+>| | | | for Betts' |
+>| | | | update |
+>| | | | dampening term |
+>+-----------------+-----------------+-----------------+-----------------+
+>| SwitchingDelta | OT_REAL | 0.010 | Filter |
+>| | | | switching |
+>| | | | condition |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| SwitchingSCV | OT_REAL | 1.100 | Filter |
+>| | | | switching |
+>| | | | condition |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| SwitchingSF | OT_REAL | 2.300 | Filter |
+>| | | | switching |
+>| | | | condition |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TakeQPSol | OT_BOOLEAN | False | Evaluate QP |
+>| | | | search |
+>| | | | direction |
+>| | | | regardless of |
+>| | | | convergence |
+>+-----------------+-----------------+-----------------+-----------------+
+>| Timeout | OT_REAL | 300 | Timeout in |
+>| | | | seconds |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TolComp | OT_REAL | 0.001 | Complementarity |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TolFeas | OT_REAL | 0.000 | Feasibility |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TolOpti | OT_REAL | 0.000 | Optimality |
+>| | | | tolerance |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TolWeakActive | OT_REAL | 1 | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TooBig | OT_BOOLEAN | True | Enable too-big |
+>| | | | termination |
+>| | | | heuristics |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TooBigCV | OT_REAL | 1.000e+25 | Upper bound on |
+>| | | | constraint |
+>| | | | violation for |
+>| | | | too-big |
+>| | | | heuristic |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TooBigKKT | OT_REAL | 1.000e+30 | Upper bound on |
+>| | | | KKT values for |
+>| | | | too-big |
+>| | | | heuristic |
+>+-----------------+-----------------+-----------------+-----------------+
+>| UserDF | OT_BOOLEAN | True | Objective |
+>| | | | gradient values |
+>| | | | supplied by |
+>| | | | caller |
+>+-----------------+-----------------+-----------------+-----------------+
+>| UserDG | OT_BOOLEAN | True | Jacobian values |
+>| | | | supplied by |
+>| | | | caller |
+>+-----------------+-----------------+-----------------+-----------------+
+>| UserHM | OT_BOOLEAN | True | Hessian values |
+>| | | | supplied by |
+>| | | | caller |
+>+-----------------+-----------------+-----------------+-----------------+
+>| UserHMstructure | OT_INTEGER | 2 | Enable |
+>| | | | automatic |
+>| | | | Hessian |
+>| | | | structure |
+>| | | | generation or |
+>| | | | checking |
+>+-----------------+-----------------+-----------------+-----------------+
+>| WeakActiveSet | OT_BOOLEAN | False | (experimental) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| eps | OT_REAL | 0.000 | Machine epsilon |
+>+-----------------+-----------------+-----------------+-----------------+
+>| internalParChan | OT_INTEGER | 0 | Counter for |
+>| ged | | | changed |
+>| | | | parameters. |
+>| | | | Internal use |
+>| | | | only. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_time | OT_BOOLEAN | True | Print |
+>| | | | information |
+>| | | | about execution |
+>| | | | time |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipBarrier | OT_REAL | 7.800 | IP barrier |
+>| | | | parameter. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipComTol | OT_REAL | 0.000 | IP |
+>| | | | complementarity |
+>| | | | tolerance. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipFracBound | OT_REAL | 0.880 | IP fraction-to- |
+>| | | | the-boundary |
+>| | | | parameter. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipLsMethod | OT_STRING | None | Select the |
+>| | | | direct linear |
+>| | | | solver used by |
+>| | | | the IP method. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipMinAlpha | OT_REAL | 0.000 | IP line search |
+>| | | | minimum step |
+>| | | | size. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipRelaxDiv | OT_REAL | 2 | The relaxation |
+>| | | | term is divided |
+>| | | | by this value |
+>| | | | if successful. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipRelaxMax | OT_REAL | 0.000 | Maximum |
+>| | | | relaxation |
+>| | | | value. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipRelaxMin | OT_REAL | 0.000 | Mimimum |
+>| | | | relaxation |
+>| | | | value. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipRelaxMult | OT_REAL | 10 | The relaxation |
+>| | | | term is |
+>| | | | multiplied by |
+>| | | | this value if |
+>| | | | unsuccessful. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipResTol | OT_REAL | 0.000 | IP residuals |
+>| | | | tolerance. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_ipTryRelax | OT_BOOLEAN | True | Enable |
+>| | | | relaxation |
+>| | | | strategy when |
+>| | | | encountering an |
+>| | | | error. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_lsItMaxIter | OT_INTEGER | 1000 | Maximum number |
+>| | | | of iterations |
+>| | | | of the |
+>| | | | iterative |
+>| | | | linear solvers. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_lsItMethod | OT_STRING | None | Select the |
+>| | | | iterative |
+>| | | | linear solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_lsItPrecondM | OT_STRING | None | Select |
+>| ethod | | | preconditioner |
+>| | | | for the |
+>| | | | iterative |
+>| | | | linear solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_lsRefineMaxI | OT_INTEGER | 10 | Maximum number |
+>| ter | | | of iterative |
+>| | | | refinement |
+>| | | | steps of the |
+>| | | | direct linear |
+>| | | | solvers. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_lsScale | OT_BOOLEAN | True | Enables scaling |
+>| | | | on linear |
+>| | | | solver level. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_lsTol | OT_REAL | 0.000 | Tolerance for |
+>| | | | the linear |
+>| | | | solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_lsTrySimple | OT_BOOLEAN | False | Some matrices |
+>| | | | can be solved |
+>| | | | without calling |
+>| | | | a linear |
+>| | | | equation solver |
+>| | | | .Currently only |
+>| | | | diagonal |
+>| | | | matrices are |
+>| | | | supported.Non- |
+>| | | | diagonal |
+>| | | | matrices will |
+>| | | | besolved with |
+>| | | | the chosen |
+>| | | | linear equation |
+>| | | | solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_maxIter | OT_INTEGER | 80 | Imposes an |
+>| | | | upper limit on |
+>| | | | the number of |
+>| | | | minor solver |
+>| | | | iterations, |
+>| | | | i.e. for the |
+>| | | | quadratic |
+>| | | | subproblem |
+>| | | | solver.If the |
+>| | | | limit is |
+>| | | | reached before |
+>| | | | convergence, |
+>| | | | WORHP will |
+>| | | | activate QP |
+>| | | | recovery |
+>| | | | strategies to |
+>| | | | prevent a |
+>| | | | solver |
+>| | | | breakdown. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_method | OT_STRING | None | Select the |
+>| | | | solution method |
+>| | | | used by the QP |
+>| | | | solver. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_nsnBeta | OT_REAL | 0.900 | NSN stepsize |
+>| | | | decrease |
+>| | | | factor. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_nsnGradStep | OT_BOOLEAN | True | Enable gradient |
+>| | | | steps in the |
+>| | | | NSN method. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_nsnKKT | OT_REAL | 0.000 | NSN KKT |
+>| | | | tolerance. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_nsnLsMethod | OT_STRING | None | Select the |
+>| | | | direct linear |
+>| | | | solver used by |
+>| | | | the NSN method. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_nsnMinAlpha | OT_REAL | 0.000 | NSN line search |
+>| | | | minimum step |
+>| | | | size. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_nsnSigma | OT_REAL | 0.010 | NSN line search |
+>| | | | slope |
+>| | | | parameter. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_printLevel | OT_STRING | None | Controls the |
+>| | | | amount of QP |
+>| | | | solver output. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_scaleIntern | OT_BOOLEAN | False | Enable scaling |
+>| | | | on QP level. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_strict | OT_BOOLEAN | True | Use strict |
+>| | | | termination |
+>| | | | criteria in IP |
+>| | | | method. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-------------+
+>| Id |
+>+=============+
+>| eval_f |
+>+-------------+
+>| eval_g |
+>+-------------+
+>| eval_grad_f |
+>+-------------+
+>| eval_h |
+>+-------------+
+>| eval_jac_g |
+>+-------------+
+>
+>>List of available stats
+>
+>+--------------------+
+>| Id |
+>+====================+
+>| iter_count |
+>+--------------------+
+>| iteration |
+>+--------------------+
+>| iterations |
+>+--------------------+
+>| n_eval_f |
+>+--------------------+
+>| n_eval_g |
+>+--------------------+
+>| n_eval_grad_f |
+>+--------------------+
+>| n_eval_h |
+>+--------------------+
+>| n_eval_jac_g |
+>+--------------------+
+>| return_code |
+>+--------------------+
+>| return_status |
+>+--------------------+
+>| t_callback_fun |
+>+--------------------+
+>| t_callback_prepare |
+>+--------------------+
+>| t_eval_f |
+>+--------------------+
+>| t_eval_g |
+>+--------------------+
+>| t_eval_grad_f |
+>+--------------------+
+>| t_eval_h |
+>+--------------------+
+>| t_eval_jac_g |
+>+--------------------+
+>| t_mainloop |
+>+--------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>scpgen
+>------
+>
+>
+>
+>A structure-exploiting sequential quadratic programming (to be come
+>sequential convex programming) method for nonlinear programming.
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| beta | OT_REAL | 0.800 | Line-search |
+>| | | | parameter, |
+>| | | | restoration |
+>| | | | factor of |
+>| | | | stepsize |
+>+-----------------+-----------------+-----------------+-----------------+
+>| c1 | OT_REAL | 0.000 | Armijo |
+>| | | | condition, |
+>| | | | coefficient of |
+>| | | | decrease in |
+>| | | | merit |
+>+-----------------+-----------------+-----------------+-----------------+
+>| codegen | OT_BOOLEAN | false | C-code |
+>| | | | generation |
+>+-----------------+-----------------+-----------------+-----------------+
+>| compiler | OT_STRING | "gcc -fPIC -O2" | Compiler |
+>| | | | command to be |
+>| | | | used for |
+>| | | | compiling |
+>| | | | generated code |
+>+-----------------+-----------------+-----------------+-----------------+
+>| hessian_approxi | OT_STRING | "exact" | gauss- |
+>| mation | | | newton|exact |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lbfgs_memory | OT_INTEGER | 10 | Size of L-BFGS |
+>| | | | memory. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter | OT_INTEGER | 50 | Maximum number |
+>| | | | of SQP |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter_ls | OT_INTEGER | 1 | Maximum number |
+>| | | | of linesearch |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| merit_memsize | OT_INTEGER | 4 | Size of memory |
+>| | | | to store |
+>| | | | history of |
+>| | | | merit function |
+>| | | | values |
+>+-----------------+-----------------+-----------------+-----------------+
+>| merit_start | OT_REAL | 0.000 | Lower bound for |
+>| | | | the merit |
+>| | | | function |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| name_x | OT_STRINGVECTOR | GenericType() | Names of the |
+>| | | | variables. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_header | OT_BOOLEAN | true | Print the |
+>| | | | header with |
+>| | | | problem |
+>| | | | statistics |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_time | OT_BOOLEAN | true | Print |
+>| | | | information |
+>| | | | about execution |
+>| | | | time |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_x | OT_INTEGERVECTO | GenericType() | Which variables |
+>| | R | | to print. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_solver | OT_STRING | GenericType() | The QP solver |
+>| | | | to be used by |
+>| | | | the SQP method |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_solver_optio | OT_DICTIONARY | GenericType() | Options to be |
+>| ns | | | passed to the |
+>| | | | QP solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| reg_threshold | OT_REAL | 0.000 | Threshold for |
+>| | | | the |
+>| | | | regularization. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| regularize | OT_BOOLEAN | false | Automatic |
+>| | | | regularization |
+>| | | | of Lagrange |
+>| | | | Hessian. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_du | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | dual |
+>| | | | infeasability |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_pr | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | primal |
+>| | | | infeasibility |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_pr_step | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | the step size |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_reg | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | regularization |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-------------+
+>| Id |
+>+=============+
+>| dx |
+>+-------------+
+>| eval_f |
+>+-------------+
+>| eval_g |
+>+-------------+
+>| eval_grad_f |
+>+-------------+
+>| eval_h |
+>+-------------+
+>| eval_jac_g |
+>+-------------+
+>| qp |
+>+-------------+
+>
+>>List of available stats
+>
+>+------------+
+>| Id |
+>+============+
+>| iter_count |
+>+------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>sqpmethod
+>---------
+>
+>
+>
+>A textbook SQPMethod
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| beta | OT_REAL | 0.800 | Line-search |
+>| | | | parameter, |
+>| | | | restoration |
+>| | | | factor of |
+>| | | | stepsize |
+>+-----------------+-----------------+-----------------+-----------------+
+>| c1 | OT_REAL | 0.000 | Armijo |
+>| | | | condition, |
+>| | | | coefficient of |
+>| | | | decrease in |
+>| | | | merit |
+>+-----------------+-----------------+-----------------+-----------------+
+>| hessian_approxi | OT_STRING | "exact" | limited- |
+>| mation | | | memory|exact |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lbfgs_memory | OT_INTEGER | 10 | Size of L-BFGS |
+>| | | | memory. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter | OT_INTEGER | 50 | Maximum number |
+>| | | | of SQP |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter_ls | OT_INTEGER | 3 | Maximum number |
+>| | | | of linesearch |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| merit_memory | OT_INTEGER | 4 | Size of memory |
+>| | | | to store |
+>| | | | history of |
+>| | | | merit function |
+>| | | | values |
+>+-----------------+-----------------+-----------------+-----------------+
+>| min_step_size | OT_REAL | 0.000 | The size (inf- |
+>| | | | norm) of the |
+>| | | | step size |
+>| | | | should not |
+>| | | | become smaller |
+>| | | | than this. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_header | OT_BOOLEAN | true | Print the |
+>| | | | header with |
+>| | | | problem |
+>| | | | statistics |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_time | OT_BOOLEAN | true | Print |
+>| | | | information |
+>| | | | about execution |
+>| | | | time |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_solver | OT_STRING | GenericType() | The QP solver |
+>| | | | to be used by |
+>| | | | the SQP method |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_solver_optio | OT_DICTIONARY | GenericType() | Options to be |
+>| ns | | | passed to the |
+>| | | | QP solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| regularize | OT_BOOLEAN | false | Automatic |
+>| | | | regularization |
+>| | | | of Lagrange |
+>| | | | Hessian. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_du | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | dual |
+>| | | | infeasability |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_pr | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | primal |
+>| | | | infeasibility |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-------------+
+>| Id |
+>+=============+
+>| bfgs |
+>+-------------+
+>| dx |
+>+-------------+
+>| eval_f |
+>+-------------+
+>| eval_g |
+>+-------------+
+>| eval_grad_f |
+>+-------------+
+>| eval_h |
+>+-------------+
+>| eval_jac_g |
+>+-------------+
+>| qp |
+>+-------------+
+>
+>>List of available stats
+>
+>+--------------------+
+>| Id |
+>+====================+
+>| iter_count |
+>+--------------------+
+>| iteration |
+>+--------------------+
+>| iterations |
+>+--------------------+
+>| n_eval_f |
+>+--------------------+
+>| n_eval_g |
+>+--------------------+
+>| n_eval_grad_f |
+>+--------------------+
+>| n_eval_h |
+>+--------------------+
+>| n_eval_jac_g |
+>+--------------------+
+>| return_status |
+>+--------------------+
+>| t_callback_fun |
+>+--------------------+
+>| t_callback_prepare |
+>+--------------------+
+>| t_eval_f |
+>+--------------------+
+>| t_eval_g |
+>+--------------------+
+>| t_eval_grad_f |
+>+--------------------+
+>| t_eval_h |
+>+--------------------+
+>| t_eval_jac_g |
+>+--------------------+
+>| t_mainloop |
+>+--------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>stabilizedsqp
+>-------------
+>
+>
+>
+>Stabilized Sequential Quadratic Programming method.
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| TReta1 | OT_REAL | 0.800 | Required |
+>| | | | predicted / |
+>| | | | actual decrease |
+>| | | | for TR increase |
+>+-----------------+-----------------+-----------------+-----------------+
+>| TReta2 | OT_REAL | 0.200 | Required |
+>| | | | predicted / |
+>| | | | actual decrease |
+>| | | | for TR decrease |
+>+-----------------+-----------------+-----------------+-----------------+
+>| alphaMin | OT_REAL | 0.001 | Used to check |
+>| | | | whether to |
+>| | | | increase rho. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| beta | OT_REAL | 0.500 | Line-search |
+>| | | | parameter, |
+>| | | | restoration |
+>| | | | factor of |
+>| | | | stepsize |
+>+-----------------+-----------------+-----------------+-----------------+
+>| c1 | OT_REAL | 0.001 | Armijo |
+>| | | | condition, |
+>| | | | coefficient of |
+>| | | | decrease in |
+>| | | | merit |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dvMax0 | OT_REAL | 100 | Parameter used |
+>| | | | to defined the |
+>| | | | max step |
+>| | | | length. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| eps_active | OT_REAL | 0.000 | Threshold for |
+>| | | | the epsilon- |
+>| | | | active set. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gamma1 | OT_REAL | 2 | Trust region |
+>| | | | increase |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gamma2 | OT_REAL | 1 | Trust region |
+>| | | | update |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gamma3 | OT_REAL | 1 | Trust region |
+>| | | | decrease |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| hessian_approxi | OT_STRING | "exact" | limited- |
+>| mation | | | memory|exact |
+>+-----------------+-----------------+-----------------+-----------------+
+>| lbfgs_memory | OT_INTEGER | 10 | Size of L-BFGS |
+>| | | | memory. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter | OT_INTEGER | 100 | Maximum number |
+>| | | | of SQP |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_iter_ls | OT_INTEGER | 20 | Maximum number |
+>| | | | of linesearch |
+>| | | | iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| max_time | OT_REAL | 1.000e+12 | Timeout |
+>+-----------------+-----------------+-----------------+-----------------+
+>| merit_memory | OT_INTEGER | 4 | Size of memory |
+>| | | | to store |
+>| | | | history of |
+>| | | | merit function |
+>| | | | values |
+>+-----------------+-----------------+-----------------+-----------------+
+>| min_step_size | OT_REAL | 0.000 | The size (inf- |
+>| | | | norm) of the |
+>| | | | step size |
+>| | | | should not |
+>| | | | become smaller |
+>| | | | than this. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| muR0 | OT_REAL | 0.000 | Initial choice |
+>| | | | of |
+>| | | | regularization |
+>| | | | parameter |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nu | OT_REAL | 1 | Parameter for |
+>| | | | primal-dual |
+>| | | | augmented |
+>| | | | Lagrangian. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| phiWeight | OT_REAL | 0.000 | Weight used in |
+>| | | | pseudo-filter. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_header | OT_BOOLEAN | true | Print the |
+>| | | | header with |
+>| | | | problem |
+>| | | | statistics |
+>+-----------------+-----------------+-----------------+-----------------+
+>| regularize | OT_BOOLEAN | false | Automatic |
+>| | | | regularization |
+>| | | | of Lagrange |
+>| | | | Hessian. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| stabilized_qp_s | OT_STRING | GenericType() | The Stabilized |
+>| olver | | | QP solver to be |
+>| | | | used by the SQP |
+>| | | | method |
+>+-----------------+-----------------+-----------------+-----------------+
+>| stabilized_qp_s | OT_DICTIONARY | GenericType() | Options to be |
+>| olver_options | | | passed to the |
+>| | | | Stabilized QP |
+>| | | | solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tau0 | OT_REAL | 0.010 | Initial |
+>| | | | parameter for |
+>| | | | the merit |
+>| | | | function |
+>| | | | optimality |
+>| | | | threshold. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_du | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | dual |
+>| | | | infeasability |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol_pr | OT_REAL | 0.000 | Stopping |
+>| | | | criterion for |
+>| | | | primal |
+>| | | | infeasibility |
+>+-----------------+-----------------+-----------------+-----------------+
+>| yEinitial | OT_STRING | "simple" | Initial |
+>| | | | multiplier. |
+>| | | | Simple (all |
+>| | | | zero) or least |
+>| | | | (LSQ). |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available monitors
+>
+>+-------------+
+>| Id |
+>+=============+
+>| dx |
+>+-------------+
+>| eval_f |
+>+-------------+
+>| eval_g |
+>+-------------+
+>| eval_grad_f |
+>+-------------+
+>| eval_h |
+>+-------------+
+>| eval_jac_g |
+>+-------------+
+>| qp |
+>+-------------+
+>
+>>List of available stats
+>
+>+---------------+
+>| Id |
+>+===============+
+>| iter_count |
+>+---------------+
+>| return_status |
+>+---------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: nlp_solver.hpp
+-}
+newtype NlpSolver = NlpSolver (ForeignPtr NlpSolver')
+-- typeclass decl
+class NlpSolverClass a where
+ castNlpSolver :: a -> NlpSolver
+instance NlpSolverClass NlpSolver where
+ castNlpSolver = id
+
+-- baseclass instances
+instance FunctionClass NlpSolver where
+ castFunction (NlpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass NlpSolver where
+ castOptionsFunctionality (NlpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass NlpSolver where
+ castSharedObject (NlpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass NlpSolver where
+ castIOInterfaceFunction (NlpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal NlpSolver (Ptr NlpSolver') where
+ marshal (NlpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (NlpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__NlpSolver"
+ c_delete_casadi__NlpSolver :: FunPtr (Ptr NlpSolver' -> IO ())
+instance WrapReturn (Ptr NlpSolver') NlpSolver where
+ wrapReturn = (fmap NlpSolver) . (newForeignPtr c_delete_casadi__NlpSolver)
+
+
+-- raw decl
+data Nullspace'
+-- data decl
+{-|
+>Base class for nullspace construction.
+>
+>Constructs a basis for the null-space of a fat matrix A. i.e. finds Z such
+>that AZ = 0 holds.
+>
+>The nullspace is also known as the orthogonal complement of the rowspace of
+>a matrix.
+>
+>It is assumed that the matrix A is of full rank.
+>
+>Implementations are not required to construct an orthogonal or orthonormal
+>basis Joris Gillis
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| dense | OT_BOOLEAN | true | Indicates | casadi::Null |
+>| | | | that dense | spaceInterna |
+>| | | | matrices can | l |
+>| | | | be assumed | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: nullspace.hpp
+-}
+newtype Nullspace = Nullspace (ForeignPtr Nullspace')
+-- typeclass decl
+class NullspaceClass a where
+ castNullspace :: a -> Nullspace
+instance NullspaceClass Nullspace where
+ castNullspace = id
+
+-- baseclass instances
+instance FunctionClass Nullspace where
+ castFunction (Nullspace x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass Nullspace where
+ castOptionsFunctionality (Nullspace x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass Nullspace where
+ castSharedObject (Nullspace x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass Nullspace where
+ castIOInterfaceFunction (Nullspace x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Nullspace (Ptr Nullspace') where
+ marshal (Nullspace x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Nullspace x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Nullspace"
+ c_delete_casadi__Nullspace :: FunPtr (Ptr Nullspace' -> IO ())
+instance WrapReturn (Ptr Nullspace') Nullspace where
+ wrapReturn = (fmap Nullspace) . (newForeignPtr c_delete_casadi__Nullspace)
+
+
+-- raw decl
+data OptionsFunctionality'
+-- data decl
+{-|
+>Provides options setting/getting functionality.
+>
+>Gives a derived class the ability to set and retrieve options in a
+>convenient way. It also contains error checking, making sure that the option
+>exists and that the value type is correct.
+>
+>A derived class should add option names, types and default values to the
+>corresponding vectors.
+>
+>Joel Andersson
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: options_functionality.hpp
+-}
+newtype OptionsFunctionality = OptionsFunctionality (ForeignPtr OptionsFunctionality')
+-- typeclass decl
+class OptionsFunctionalityClass a where
+ castOptionsFunctionality :: a -> OptionsFunctionality
+instance OptionsFunctionalityClass OptionsFunctionality where
+ castOptionsFunctionality = id
+
+-- baseclass instances
+instance SharedObjectClass OptionsFunctionality where
+ castSharedObject (OptionsFunctionality x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal OptionsFunctionality (Ptr OptionsFunctionality') where
+ marshal (OptionsFunctionality x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (OptionsFunctionality x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__OptionsFunctionality"
+ c_delete_casadi__OptionsFunctionality :: FunPtr (Ptr OptionsFunctionality' -> IO ())
+instance WrapReturn (Ptr OptionsFunctionality') OptionsFunctionality where
+ wrapReturn = (fmap OptionsFunctionality) . (newForeignPtr c_delete_casadi__OptionsFunctionality)
+
+
+-- raw decl
+data Parallelizer'
+-- data decl
+{-|
+>Parallelizer execution of functions.
+>
+>Joel Andersson
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| parallelizat | OT_STRING | "serial" | (serial|open | casadi::Para |
+>| ion | | | mp|mpi) | llelizerInte |
+>| | | | | rnal |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>>List of available stats
+>
+>+-----------------+------------------------------+
+>| Id | Used in |
+>+=================+==============================+
+>| max_threads | casadi::ParallelizerInternal |
+>+-----------------+------------------------------+
+>| num_threads | casadi::ParallelizerInternal |
+>+-----------------+------------------------------+
+>| task_allocation | casadi::ParallelizerInternal |
+>+-----------------+------------------------------+
+>| task_cputime | casadi::ParallelizerInternal |
+>+-----------------+------------------------------+
+>| task_endtime | casadi::ParallelizerInternal |
+>+-----------------+------------------------------+
+>| task_order | casadi::ParallelizerInternal |
+>+-----------------+------------------------------+
+>| task_starttime | casadi::ParallelizerInternal |
+>+-----------------+------------------------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: parallelizer.hpp
+-}
+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
+{-|
+>QcqpSolver.
+>
+>Solves the following strictly convex problem:
+>
+>
+>
+>::
+>
+> min 1/2 x' H x + g' x
+> x
+>
+> subject to
+> 1/2 x' Pi x + qi' x + ri <= 0 for i=0..nq-1
+> LBA <= A x <= UBA
+> LBX <= x <= UBX
+>
+> with :
+> H, Pi sparse (n x n) positive definite
+> g, qi dense (n x 1)
+> ri scalar
+>
+> n: number of decision variables (x)
+> nc: number of linear constraints (A)
+> nq: number of quadratic constraints
+>
+>
+>
+>If H, Pi is not positive-definite, the solver should throw an error.
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::QcqpSolverInput (QCQP_SOLVER_NUM_IN = 12) [qcqpIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| QCQP_SOLVER_H | h | The square matrix H: |
+>| | | sparse, (n x n). Only |
+>| | | the lower triangular |
+>| | | part is actually used. |
+>| | | The matrix is assumed |
+>| | | to be symmetrical. |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_G | g | The vector g: dense, |
+>| | | (n x 1) . |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_P | p | The horizontal stack |
+>| | | of all Pi. Each Pi is |
+>| | | sparse (n x n). Only |
+>| | | the lower triangular |
+>| | | part is actually used. |
+>| | | The matrix is assumed |
+>| | | to be symmetrical. |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_Q | q | The vertical stack of |
+>| | | all qi: dense, (nq n x |
+>| | | 1) . |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_R | r | The vertical stack of |
+>| | | all scalars ri (nq x |
+>| | | 1) . |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_A | a | The matrix A: sparse, |
+>| | | (nc x n) - product |
+>| | | with x must be dense. |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_LBA | lba | dense, (nc x 1) |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_UBA | uba | dense, (nc x 1) |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_LBX | lbx | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_UBX | ubx | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_X0 | x0 | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_LAM_X0 | lam_x0 | dense |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::QcqpSolverOutput (QCQP_SOLVER_NUM_OUT = 4) [qcqpOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| QCQP_SOLVER_X | x | The primal solution . |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_COST | cost | The optimal cost . |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_LAM_A | lam_a | The dual solution |
+>| | | corresponding to |
+>| | | linear bounds . |
+>+------------------------+------------------------+------------------------+
+>| QCQP_SOLVER_LAM_X | lam_x | The dual solution |
+>| | | corresponding to |
+>| | | simple bounds . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- socp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>QcqpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>socp
+>----
+>
+>
+>
+>Solve a QCQP with an SocpSolver
+>
+>Note: this implementation relies on Cholesky decomposition: Chol(H) = L -> H
+>= LL' with L lower triangular This requires Pi, H to be positive definite.
+>Positive semi-definite is not sufficient. Notably, H==0 will not work.
+>
+>A better implementation would rely on matrix square root, but we need
+>singular value decomposition to implement that.
+>
+>This implementation makes use of the epigraph reformulation:
+>
+>::
+>
+> * min f(x)
+> * x
+> *
+> * min t
+> * x, t f(x) <= t
+> *
+>
+>
+>
+>This implementation makes use of the following identity:
+>
+>::
+>
+> * || Gx+h||_2 <= e'x + f
+> *
+> * x'(G'G - ee')x + (2 h'G - 2 f e') x + h'h - f <= 0
+> *
+>
+>where we put e = [0 0 ... 1] for the quadratic constraint arising from the
+>epigraph reformulation and e==0 for all other quadratic constraints.
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>>List of available stats
+>
+>+-------------------+
+>| Id |
+>+===================+
+>| socp_solver_stats |
+>+-------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: qcqp_solver.hpp
+-}
+newtype QcqpSolver = QcqpSolver (ForeignPtr QcqpSolver')
+-- typeclass decl
+class QcqpSolverClass a where
+ castQcqpSolver :: a -> QcqpSolver
+instance QcqpSolverClass QcqpSolver where
+ castQcqpSolver = id
+
+-- baseclass instances
+instance FunctionClass QcqpSolver where
+ castFunction (QcqpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass QcqpSolver where
+ castOptionsFunctionality (QcqpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass QcqpSolver where
+ castSharedObject (QcqpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass QcqpSolver where
+ castIOInterfaceFunction (QcqpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal QcqpSolver (Ptr QcqpSolver') where
+ marshal (QcqpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (QcqpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__QcqpSolver"
+ c_delete_casadi__QcqpSolver :: FunPtr (Ptr QcqpSolver' -> IO ())
+instance WrapReturn (Ptr QcqpSolver') QcqpSolver where
+ wrapReturn = (fmap QcqpSolver) . (newForeignPtr c_delete_casadi__QcqpSolver)
+
+
+-- raw decl
+data QpSolver'
+-- data decl
+{-|
+>QpSolver.
+>
+>Solves the following strictly convex problem:
+>
+>
+>
+>::
+>
+> min 1/2 x' H x + g' x
+> x
+>
+> subject to
+> LBA <= A x <= UBA
+> LBX <= x <= UBX
+>
+> with :
+> H sparse (n x n) positive definite
+> g dense (n x 1)
+>
+> n: number of decision variables (x)
+> nc: number of constraints (A)
+>
+>
+>
+>If H is not positive-definite, the solver should throw an error.
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::QpSolverInput (QP_SOLVER_NUM_IN = 9) [qpIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| QP_SOLVER_H | h | The square matrix H: |
+>| | | sparse, (n x n). Only |
+>| | | the lower triangular |
+>| | | part is actually used. |
+>| | | The matrix is assumed |
+>| | | to be symmetrical. |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_G | g | The vector g: dense, |
+>| | | (n x 1) . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_A | a | The matrix A: sparse, |
+>| | | (nc x n) - product |
+>| | | with x must be dense. |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_LBA | lba | dense, (nc x 1) |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_UBA | uba | dense, (nc x 1) |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_LBX | lbx | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_UBX | ubx | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_X0 | x0 | dense, (n x 1) |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_LAM_X0 | lam_x0 | dense |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::QpSolverOutput (QP_SOLVER_NUM_OUT = 4) [qpOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| QP_SOLVER_X | x | The primal solution . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_COST | cost | The optimal cost . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_LAM_A | lam_a | The dual solution |
+>| | | corresponding to |
+>| | | linear bounds . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_LAM_X | lam_x | The dual solution |
+>| | | corresponding to |
+>| | | simple bounds . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- cplex
+>
+>- ooqp
+>
+>- qpoases
+>
+>- sqic
+>
+>- nlp
+>
+>- qcqp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>QpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>cplex
+>-----
+>
+>
+>
+>Interface to Cplex solver for sparse Quadratic Programs
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| barrier_maxiter | OT_INTEGER | 2.100e+09 | Maximum number |
+>| | | | of barrier |
+>| | | | iterations. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| convex | OT_BOOLEAN | true | Indicates if |
+>| | | | the QP is |
+>| | | | convex or not |
+>| | | | (affects only |
+>| | | | the barrier |
+>| | | | method). |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dep_check | OT_STRING | "off" | Detect |
+>| | | | redundant |
+>| | | | constraints. (a |
+>| | | | utomatic:-1|off |
+>| | | | :0|begin:1|end: |
+>| | | | 2|both:3) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dump_filename | OT_STRING | "qp.dat" | The filename to |
+>| | | | dump to. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dump_to_file | OT_BOOLEAN | false | Dumps QP to |
+>| | | | file in CPLEX |
+>| | | | format. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_method | OT_STRING | "automatic" | Determines |
+>| | | | which CPLEX |
+>| | | | algorithm to |
+>| | | | use. (automatic |
+>| | | | |primal_simplex |
+>| | | | |dual_simplex|n |
+>| | | | etwork|barrier| |
+>| | | | sifting|concurr |
+>| | | | ent|crossover) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| simplex_maxiter | OT_INTEGER | 2.100e+09 | Maximum number |
+>| | | | of simplex |
+>| | | | iterations. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| tol | OT_REAL | 0.000 | Tolerance of |
+>| | | | solver |
+>+-----------------+-----------------+-----------------+-----------------+
+>| warm_start | OT_BOOLEAN | false | Use warm start |
+>| | | | with simplex |
+>| | | | methods |
+>| | | | (affects only |
+>| | | | the simplex |
+>| | | | methods). |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>ooqp
+>----
+>
+>
+>
+>Interface to the OOQP Solver for quadratic programming The current
+>implementation assumes that OOQP is configured with the MA27 sparse linear
+>solver.
+>
+>NOTE: when doing multiple calls to evaluate(), check if you need to
+>reInit();
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| artol | OT_REAL | 0.000 | tolerance as |
+>| | | | provided with |
+>| | | | setArTol to |
+>| | | | OOQP |
+>+-----------------+-----------------+-----------------+-----------------+
+>| mutol | OT_REAL | 0.000 | tolerance as |
+>| | | | provided with |
+>| | | | setMuTol to |
+>| | | | OOQP |
+>+-----------------+-----------------+-----------------+-----------------+
+>| print_level | OT_INTEGER | 0 | Print level. |
+>| | | | OOQP listens to |
+>| | | | print_level 0, |
+>| | | | 10 and 100 |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>qpoases
+>-------
+>
+>
+>
+>Interface to QPOases Solver for quadratic programming
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| CPUtime | OT_REAL | None | The maximum |
+>| | | | allowed CPU |
+>| | | | time in seconds |
+>| | | | for the whole |
+>| | | | initialisation |
+>| | | | (and the |
+>| | | | actually |
+>| | | | required one on |
+>| | | | output). |
+>| | | | Disabled if |
+>| | | | unset. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| boundRelaxation | OT_REAL | 10000 | Initial |
+>| | | | relaxation of |
+>| | | | bounds to start |
+>| | | | homotopy and |
+>| | | | initial value |
+>| | | | for far bounds. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| boundTolerance | OT_REAL | 0.000 | If upper and |
+>| | | | lower bounds |
+>| | | | differ less |
+>| | | | than this |
+>| | | | tolerance, they |
+>| | | | are regarded |
+>| | | | equal, i.e. as |
+>| | | | equality |
+>| | | | constraint. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableCholeskyR | OT_INTEGER | 0 | Specifies the |
+>| efactorisation | | | frequency of a |
+>| | | | full re- |
+>| | | | factorisation |
+>| | | | of projected |
+>| | | | Hessian matrix: |
+>| | | | 0: turns them |
+>| | | | off, 1: uses |
+>| | | | them at each |
+>| | | | iteration etc. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableDriftCorr | OT_INTEGER | 1 | Specifies the |
+>| ection | | | frequency of |
+>| | | | drift |
+>| | | | corrections: 0: |
+>| | | | turns them off. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableEqualitie | OT_BOOLEAN | False | Specifies |
+>| s | | | whether |
+>| | | | equalities |
+>| | | | should be |
+>| | | | treated as |
+>| | | | always active |
+>| | | | (True) or not |
+>| | | | (False) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableFarBounds | OT_BOOLEAN | True | Enables the use |
+>| | | | of far bounds. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableFlippingB | OT_BOOLEAN | True | Enables the use |
+>| ounds | | | of flipping |
+>| | | | bounds. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableFullLITes | OT_BOOLEAN | False | Enables |
+>| ts | | | condition- |
+>| | | | hardened (but |
+>| | | | more expensive) |
+>| | | | LI test. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableNZCTests | OT_BOOLEAN | True | Enables nonzero |
+>| | | | curvature |
+>| | | | tests. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableRamping | OT_BOOLEAN | True | Enables |
+>| | | | ramping. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| enableRegularis | OT_BOOLEAN | False | Enables |
+>| ation | | | automatic |
+>| | | | Hessian |
+>| | | | regularisation. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsDen | OT_REAL | 0.000 | Denominator |
+>| | | | tolerance for |
+>| | | | ratio tests. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsFlipping | OT_REAL | 0.000 | Tolerance of |
+>| | | | squared |
+>| | | | Cholesky |
+>| | | | diagonal factor |
+>| | | | which triggers |
+>| | | | flipping bound. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsIterRef | OT_REAL | 0.000 | Early |
+>| | | | termination |
+>| | | | tolerance for |
+>| | | | iterative |
+>| | | | refinement. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsLITests | OT_REAL | 0.000 | Tolerance for |
+>| | | | linear |
+>| | | | independence |
+>| | | | tests. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsNZCTests | OT_REAL | 0.000 | Tolerance for |
+>| | | | nonzero |
+>| | | | curvature |
+>| | | | tests. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsNum | OT_REAL | -0.000 | Numerator |
+>| | | | tolerance for |
+>| | | | ratio tests. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| epsRegularisati | OT_REAL | 0.000 | Scaling factor |
+>| on | | | of identity |
+>| | | | matrix used for |
+>| | | | Hessian |
+>| | | | regularisation. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| finalRamping | OT_REAL | 1 | Final value for |
+>| | | | ramping |
+>| | | | strategy. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| growFarBounds | OT_REAL | 1000 | Factor to grow |
+>| | | | far bounds. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| initialFarBound | OT_REAL | 1000000 | Initial size |
+>| s | | | for far bounds. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| initialRamping | OT_REAL | 0.500 | Start value for |
+>| | | | ramping |
+>| | | | strategy. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| initialStatusBo | OT_STRING | lower | Initial status |
+>| unds | | | of bounds at |
+>| | | | first |
+>| | | | iteration. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| maxDualJump | OT_REAL | 100000000 | Maximum allowed |
+>| | | | jump in dual |
+>| | | | variables in |
+>| | | | linear |
+>| | | | independence |
+>| | | | tests. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| maxPrimalJump | OT_REAL | 100000000 | Maximum allowed |
+>| | | | jump in primal |
+>| | | | variables in |
+>| | | | nonzero |
+>| | | | curvature |
+>| | | | tests. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| nWSR | OT_INTEGER | None | The maximum |
+>| | | | number of |
+>| | | | working set |
+>| | | | recalculations |
+>| | | | to be performed |
+>| | | | during the |
+>| | | | initial |
+>| | | | homotopy. |
+>| | | | Default is 5(nx |
+>| | | | + nc) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| numRefinementSt | OT_INTEGER | 1 | Maximum number |
+>| eps | | | of iterative |
+>| | | | refinement |
+>| | | | steps. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| numRegularisati | OT_INTEGER | 0 | Maximum number |
+>| onSteps | | | of successive |
+>| | | | regularisation |
+>| | | | steps. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| printLevel | OT_STRING | medium | Defines the |
+>| | | | amount of text |
+>| | | | output during |
+>| | | | QP solution, |
+>| | | | see Section 5.7 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| terminationTole | OT_REAL | 0.000 | Relative |
+>| rance | | | termination |
+>| | | | tolerance to |
+>| | | | stop homotopy. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>sqic
+>----
+>
+>
+>
+>Interface to the SQIC solver for quadratic programming
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>nlp
+>---
+>
+>
+>
+>Solve QPs using an NlpSolver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>>List of available stats
+>
+>+------------------+
+>| Id |
+>+==================+
+>| nlp_solver_stats |
+>+------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>qcqp
+>----
+>
+>
+>
+>Solve QP using a QcqpSolver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>>List of available stats
+>
+>+-------------------+
+>| Id |
+>+===================+
+>| qcqp_solver_stats |
+>+-------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: qp_solver.hpp
+-}
+newtype QpSolver = QpSolver (ForeignPtr QpSolver')
+-- typeclass decl
+class QpSolverClass a where
+ castQpSolver :: a -> QpSolver
+instance QpSolverClass QpSolver where
+ castQpSolver = id
+
+-- baseclass instances
+instance FunctionClass QpSolver where
+ castFunction (QpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass QpSolver where
+ castOptionsFunctionality (QpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass QpSolver where
+ castSharedObject (QpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass QpSolver where
+ castIOInterfaceFunction (QpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal QpSolver (Ptr QpSolver') where
+ marshal (QpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (QpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__QpSolver"
+ c_delete_casadi__QpSolver :: FunPtr (Ptr QpSolver' -> IO ())
+instance WrapReturn (Ptr QpSolver') QpSolver where
+ wrapReturn = (fmap QpSolver) . (newForeignPtr c_delete_casadi__QpSolver)
+
+
+-- raw decl
+data SX'
+-- data decl
+{-|
+-}
+newtype SX = SX (ForeignPtr SX')
+-- typeclass decl
+class SXClass a where
+ castSX :: a -> SX
+instance SXClass SX where
+ castSX = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal SX (Ptr SX') where
+ marshal (SX x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (SX x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SX"
+ c_delete_casadi__SX :: FunPtr (Ptr SX' -> IO ())
+instance WrapReturn (Ptr SX') SX where
+ wrapReturn = (fmap SX) . (newForeignPtr c_delete_casadi__SX)
+
+
+-- 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
+{-|
+>Dynamically created function that can be expanded into a series of scalar
+>operations.
+>
+>Joel Andersson
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| just_in_time | OT_BOOLEAN | false | Just-in-time | casadi::SXFu |
+>| _opencl | | | compilation | nctionIntern |
+>| | | | for numeric | al |
+>| | | | evaluation | |
+>| | | | using OpenCL | |
+>| | | | (experimenta | |
+>| | | | l) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| just_in_time | OT_BOOLEAN | false | Propagate | casadi::SXFu |
+>| _sparsity | | | sparsity | nctionIntern |
+>| | | | patterns | al |
+>| | | | using just- | |
+>| | | | in-time | |
+>| | | | compilation | |
+>| | | | to a CPU or | |
+>| | | | GPU using | |
+>| | | | OpenCL | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: sx_function.hpp
+-}
+newtype SXFunction = SXFunction (ForeignPtr SXFunction')
+-- typeclass decl
+class SXFunctionClass a where
+ castSXFunction :: a -> SXFunction
+instance SXFunctionClass SXFunction where
+ castSXFunction = id
+
+-- baseclass instances
+instance FunctionClass SXFunction where
+ castFunction (SXFunction x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass SXFunction where
+ castOptionsFunctionality (SXFunction x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass SXFunction where
+ castSharedObject (SXFunction x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass SXFunction where
+ castIOInterfaceFunction (SXFunction x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal SXFunction (Ptr SXFunction') where
+ marshal (SXFunction x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (SXFunction x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SXFunction"
+ c_delete_casadi__SXFunction :: FunPtr (Ptr SXFunction' -> IO ())
+instance WrapReturn (Ptr SXFunction') SXFunction where
+ wrapReturn = (fmap SXFunction) . (newForeignPtr c_delete_casadi__SXFunction)
+
+
+-- raw decl
+data SdpSolver'
+-- data decl
+{-|
+>SdpSolver.
+>
+>Solves an SDP problem in standard form.
+>Seehttp://sdpa.indsys.chuo-u.ac.jp/sdpa/files/sdpa-c.6.2.0.manual.pdf
+>
+>Primal:
+>
+>
+>
+>::
+>
+> min c' x
+> x
+> subject to
+> P = Sum_i^m F_i x_i - G
+> P negative semidefinite
+>
+> LBA <= A x <= UBA
+> LBX <= x <= UBX
+>
+> with x ( n x 1)
+> c ( n x 1 )
+> G, F_i sparse symmetric (m x m)
+> X dense symmetric ( m x m )
+> A sparse matrix ( nc x n)
+> LBA, UBA dense vector (nc x 1)
+> LBX, UBX dense vector (n x 1)
+>
+>
+>
+>This formulation is chosen as primal, because it does not call for a large
+>decision variable space.
+>
+>Dual:
+>
+>
+>
+>::
+>
+> max trace(G Y)
+> Y
+>
+> subject to
+> trace(F_i Y) = c_i
+> Y positive semidefinite
+>
+> with Y dense symmetric ( m x m)
+>
+>
+>
+>On generality: you might have formulation with block partitioning:
+>
+>Primal:
+>
+>
+>
+>::
+>
+> min c' x
+> x
+> subject to
+> Pj = Sum_i^m F_ij x_i - gj for all j
+> Pj negative semidefinite for all j
+>
+> with x ( n x 1)
+> c ( n x 1 )
+> G, F_i sparse symmetric (m x m)
+> X dense symmetric ( m x m )
+>
+>
+>
+>Dual:
+>
+>::
+>
+> max Sum_j trace(Gj Yj)
+> Yj
+>
+> subject to
+> Sum_j trace(F_ij Yj) = c_i for all j
+> Yj positive semidefinite for all j
+>
+> with Y dense symmetric ( m x m)
+>
+>
+>
+>You can cast this into the standard form with: G = blkdiag(Gj for all j) Fi
+>= blkdiag(F_ij for all j)
+>
+>Implementations of SdpSolver are encouraged to exploit this block structure.
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::SDPInput (SDP_SOLVER_NUM_IN = 8) [sdpIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| SDP_SOLVER_F | f | The horizontal stack |
+>| | | of all matrices F_i: ( |
+>| | | m x nm) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_C | c | The vector c: ( n x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_G | g | The matrix G: ( m x m) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_A | a | The matrix A: ( nc x |
+>| | | n) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_LBA | lba | Lower bounds on Ax ( |
+>| | | nc x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_UBA | uba | Upper bounds on Ax ( |
+>| | | nc x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_LBX | lbx | Lower bounds on x ( n |
+>| | | x 1 ) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_UBX | ubx | Upper bounds on x ( n |
+>| | | x 1 ) . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::SDPOutput (SDP_SOLVER_NUM_OUT = 7) [sdpOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| SDP_SOLVER_X | x | The primal solution (n |
+>| | | x 1) - may be used as |
+>| | | initial guess . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_P | p | The solution P (m x m) |
+>| | | - may be used as |
+>| | | initial guess . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_DUAL | dual | The dual solution (m x |
+>| | | m) - may be used as |
+>| | | initial guess . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_COST | cost | The primal optimal |
+>| | | cost (1 x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_DUAL_COST | dual_cost | The dual optimal cost |
+>| | | (1 x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_LAM_A | lam_a | The dual solution |
+>| | | corresponding to the |
+>| | | linear constraints (nc |
+>| | | x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDP_SOLVER_LAM_X | lam_x | The dual solution |
+>| | | corresponding to |
+>| | | simple bounds (n x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| calc_dual | OT_BOOLEAN | true | Indicate if | casadi::SdpS |
+>| | | | dual should | olverInterna |
+>| | | | be allocated | l |
+>| | | | and | |
+>| | | | calculated. | |
+>| | | | You may want | |
+>| | | | to avoid | |
+>| | | | calculating | |
+>| | | | this | |
+>| | | | variable for | |
+>| | | | problems | |
+>| | | | with n | |
+>| | | | large, as is | |
+>| | | | always dense | |
+>| | | | (m x m). | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| calc_p | OT_BOOLEAN | true | Indicate if | casadi::SdpS |
+>| | | | the P-part | olverInterna |
+>| | | | of primal | l |
+>| | | | solution | |
+>| | | | should be | |
+>| | | | allocated | |
+>| | | | and | |
+>| | | | calculated. | |
+>| | | | You may want | |
+>| | | | to avoid | |
+>| | | | calculating | |
+>| | | | this | |
+>| | | | variable for | |
+>| | | | problems | |
+>| | | | with n | |
+>| | | | large, as is | |
+>| | | | always dense | |
+>| | | | (m x m). | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| print_proble | OT_BOOLEAN | false | Print out | casadi::SdpS |
+>| m | | | problem | olverInterna |
+>| | | | statement | l |
+>| | | | for | |
+>| | | | debugging. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- dsdp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>SdpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>dsdp
+>----
+>
+>
+>
+>Interface to the SDP solver DSDP Warning: The solver DSDP is not good at
+>handling linear equalities. There are several options if you notice
+>difficulties: play around with the parameter "_penalty" leave a gap
+>manually switch to another SDP Solver
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| _loglevel | OT_INTEGER | 0 | An integer that |
+>| | | | specifies how |
+>| | | | much logging is |
+>| | | | done on stdout. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| _penalty | OT_REAL | 100000 | Penality |
+>| | | | parameter |
+>| | | | lambda. Must |
+>| | | | exceed the |
+>| | | | trace of Y. |
+>| | | | This parameter |
+>| | | | heavily |
+>| | | | influences the |
+>| | | | ability of DSDP |
+>| | | | to treat linear |
+>| | | | equalities. The |
+>| | | | DSDP standard |
+>| | | | default (1e8) |
+>| | | | will make a |
+>| | | | problem with |
+>| | | | linear equality |
+>| | | | return unusable |
+>| | | | solutions. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| _printlevel | OT_INTEGER | 1 | A printlevel of |
+>| | | | zero will |
+>| | | | disable all |
+>| | | | output. Another |
+>| | | | number |
+>| | | | indicates how |
+>| | | | often a line is |
+>| | | | printed. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| _reuse | OT_INTEGER | 4 | Maximum on the |
+>| | | | number of times |
+>| | | | the Schur |
+>| | | | complement |
+>| | | | matrix is |
+>| | | | reused |
+>+-----------------+-----------------+-----------------+-----------------+
+>| _rho | OT_REAL | 4 | Potential |
+>| | | | parameter. Must |
+>| | | | be >=1 |
+>+-----------------+-----------------+-----------------+-----------------+
+>| _use_penalty | OT_BOOLEAN | true | Modifies the |
+>| | | | algorithm to |
+>| | | | use a penality |
+>| | | | gamma on r. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| _zbar | OT_REAL | 1.000e+10 | Initial upper |
+>| | | | bound on the |
+>| | | | objective of |
+>| | | | the dual |
+>| | | | problem. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| dualTol | OT_REAL | 0.000 | Tolerance for |
+>| | | | dual |
+>| | | | infeasibility |
+>| | | | (translates to |
+>| | | | primal |
+>| | | | infeasibility |
+>| | | | in dsdp terms) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| gapTol | OT_REAL | 0.000 | Convergence |
+>| | | | criterion based |
+>| | | | on distance |
+>| | | | between primal |
+>| | | | and dual |
+>| | | | objective |
+>+-----------------+-----------------+-----------------+-----------------+
+>| inf | OT_REAL | 1.000e+30 | Treat numbers |
+>| | | | higher than |
+>| | | | this as |
+>| | | | infinity |
+>+-----------------+-----------------+-----------------+-----------------+
+>| maxIter | OT_INTEGER | 500 | Maximum number |
+>| | | | of iterations |
+>+-----------------+-----------------+-----------------+-----------------+
+>| primalTol | OT_REAL | 0.000 | Tolerance for |
+>| | | | primal |
+>| | | | infeasibility |
+>| | | | (translates to |
+>| | | | dual |
+>| | | | infeasibility |
+>| | | | in dsdp terms) |
+>+-----------------+-----------------+-----------------+-----------------+
+>| stepTol | OT_REAL | 0.050 | Terminate the |
+>| | | | solver if the |
+>| | | | step length in |
+>| | | | the primal is |
+>| | | | below this |
+>| | | | tolerance. |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available stats
+>
+>+--------------------+
+>| Id |
+>+====================+
+>| solution_type |
+>+--------------------+
+>| termination_reason |
+>+--------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: sdp_solver.hpp
+-}
+newtype SdpSolver = SdpSolver (ForeignPtr SdpSolver')
+-- typeclass decl
+class SdpSolverClass a where
+ castSdpSolver :: a -> SdpSolver
+instance SdpSolverClass SdpSolver where
+ castSdpSolver = id
+
+-- baseclass instances
+instance FunctionClass SdpSolver where
+ castFunction (SdpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass SdpSolver where
+ castOptionsFunctionality (SdpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass SdpSolver where
+ castSharedObject (SdpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass SdpSolver where
+ castIOInterfaceFunction (SdpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal SdpSolver (Ptr SdpSolver') where
+ marshal (SdpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (SdpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SdpSolver"
+ c_delete_casadi__SdpSolver :: FunPtr (Ptr SdpSolver' -> IO ())
+instance WrapReturn (Ptr SdpSolver') SdpSolver where
+ wrapReturn = (fmap SdpSolver) . (newForeignPtr c_delete_casadi__SdpSolver)
+
+
+-- raw decl
+data SdqpSolver'
+-- data decl
+{-|
+>SdqpSolver.
+>
+>Same as an SdpSolver, but with a quadratic objective 1/2 x' H x
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::SDQPInput (SDQP_SOLVER_NUM_IN = 9) [sdqpIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| SDQP_SOLVER_H | h | The matrix H: sparse ( |
+>| | | n x n) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_C | c | The vector c: ( n x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_F | f | The horizontal stack |
+>| | | of all matrices F_i: ( |
+>| | | m x nm) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_G | g | The matrix G: ( m x m) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_A | a | The matrix A: ( nc x |
+>| | | n) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_LBA | lba | Lower bounds on Ax ( |
+>| | | nc x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_UBA | uba | Upper bounds on Ax ( |
+>| | | nc x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_LBX | lbx | Lower bounds on x ( n |
+>| | | x 1 ) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_UBX | ubx | Upper bounds on x ( n |
+>| | | x 1 ) . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::SDQPOutput (SDQP_SOLVER_NUM_OUT = 7) [sdqpOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| SDQP_SOLVER_X | x | The primal solution (n |
+>| | | x 1) - may be used as |
+>| | | initial guess . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_P | p | The solution P (m x m) |
+>| | | - may be used as |
+>| | | initial guess . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_DUAL | dual | The dual solution (m x |
+>| | | m) - may be used as |
+>| | | initial guess . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_COST | cost | The primal optimal |
+>| | | cost (1 x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_DUAL_COST | dual_cost | The dual optimal cost |
+>| | | (1 x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_LAM_A | lam_a | The dual solution |
+>| | | corresponding to the |
+>| | | linear constraints (nc |
+>| | | x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SDQP_SOLVER_LAM_X | lam_x | The dual solution |
+>| | | corresponding to |
+>| | | simple bounds (n x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| sdp_solver | OT_STRING | GenericType( | The | casadi::Sdqp |
+>| | | ) | SdqpSolver | SolverIntern |
+>| | | | used to | al |
+>| | | | solve the | |
+>| | | | SDPs. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| sdp_solver_o | OT_DICTIONAR | GenericType( | Options to | casadi::Sdqp |
+>| ptions | Y | ) | be passed to | SolverIntern |
+>| | | | the | al |
+>| | | | SDPSOlver | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- sdp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>SdqpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>sdp
+>---
+>
+>
+>
+>Solve an SQDP using an SdpSolver Note: this implementation relies on
+>Cholesky decomposition: Chol(H) = L -> H = LL' with L lower triangular This
+>requires Pi, H to be positive definite. Positive semi-definite is not
+>sufficient. Notably, H==0 will not work.
+>
+>A better implementation would rely on matrix square root, but we need
+>singular value decomposition to implement that.
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>>List of available stats
+>
+>+------------------+
+>| Id |
+>+==================+
+>| sdp_solver_stats |
+>+------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: sdqp_solver.hpp
+-}
+newtype SdqpSolver = SdqpSolver (ForeignPtr SdqpSolver')
+-- typeclass decl
+class SdqpSolverClass a where
+ castSdqpSolver :: a -> SdqpSolver
+instance SdqpSolverClass SdqpSolver where
+ castSdqpSolver = id
+
+-- baseclass instances
+instance FunctionClass SdqpSolver where
+ castFunction (SdqpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass SdqpSolver where
+ castOptionsFunctionality (SdqpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass SdqpSolver where
+ castSharedObject (SdqpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass SdqpSolver where
+ castIOInterfaceFunction (SdqpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal SdqpSolver (Ptr SdqpSolver') where
+ marshal (SdqpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (SdqpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SdqpSolver"
+ c_delete_casadi__SdqpSolver :: FunPtr (Ptr SdqpSolver' -> IO ())
+instance WrapReturn (Ptr SdqpSolver') SdqpSolver where
+ wrapReturn = (fmap SdqpSolver) . (newForeignPtr c_delete_casadi__SdqpSolver)
+
+
+-- raw decl
+data SharedObject'
+-- data decl
+{-|
+>SharedObject implements a reference counting framework similar for efficient
+>and easily-maintained memory management.
+>
+>To use the class, both the SharedObject class (the public class), and the
+>SharedObjectNode class (the internal class) must be inherited from. It can
+>be done in two different files and together with memory management, this
+>approach provides a clear distinction of which methods of the class are to
+>be considered "public", i.e. methods for public use that can be considered
+>to remain over time with small changes, and the internal memory.
+>
+>When interfacing a software, which typically includes including some header
+>file, this is best done only in the file where the internal class is
+>defined, to avoid polluting the global namespace and other side effects.
+>
+>The default constructor always means creating a null pointer to an internal
+>class only. To allocate an internal class (this works only when the internal
+>class isn't abstract), use the constructor with arguments.
+>
+>The copy constructor and the assignment operator perform shallow copies
+>only, to make a deep copy you must use the clone method explicitly. This
+>will give a shared pointer instance.
+>
+>In an inheritance hierarchy, you can cast down automatically, e.g. (
+>SXFunction is a child class of Function): SXFunction derived(...); Function
+>base = derived;
+>
+>To cast up, use the shared_cast template function, which works analogously
+>to dynamic_cast, static_cast, const_cast etc, e.g.: SXFunction derived(...);
+>Function base = derived; SXFunction derived_from_base =
+>shared_cast(base);
+>
+>A failed shared_cast will result in a null pointer (cf. dynamic_cast)
+>
+>Joel Andersson
+>
+>C++ includes: shared_object.hpp
+-}
+newtype SharedObject = SharedObject (ForeignPtr SharedObject')
+-- typeclass decl
+class SharedObjectClass a where
+ castSharedObject :: a -> SharedObject
+instance SharedObjectClass SharedObject where
+ castSharedObject = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal SharedObject (Ptr SharedObject') where
+ marshal (SharedObject x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (SharedObject x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SharedObject"
+ c_delete_casadi__SharedObject :: FunPtr (Ptr SharedObject' -> IO ())
+instance WrapReturn (Ptr SharedObject') SharedObject where
+ wrapReturn = (fmap SharedObject) . (newForeignPtr c_delete_casadi__SharedObject)
+
+
+-- raw decl
+data Simulator'
+-- data decl
+{-|
+>Integrator class.
+>
+>An "simulator" integrates an IVP, stopping at a (fixed) number of grid
+>points and evaluates a set of output functions at these points. The internal
+>stepsizes of the integrator need not coincide with the gridpoints.
+>
+>Simulator is an casadi::Function mapping from casadi::IntegratorInput to n.
+>\\\\
+>
+>The output function needs to be a mapping from casadi::DAEInput to n. The
+>default output has n=1 and the output is the (vectorized) differential state
+>for each time step.
+>
+>Joel Andersson
+>
+>>Input scheme: casadi::IntegratorInput (INTEGRATOR_NUM_IN = 6) [integratorIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| INTEGRATOR_X0 | x0 | Differential state at |
+>| | | the initial time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_P | p | Parameters . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_Z0 | z0 | Initial guess for the |
+>| | | algebraic variable . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RX0 | rx0 | Backward differential |
+>| | | state at the final |
+>| | | time . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RP | rp | Backward parameter |
+>| | | vector . |
+>+------------------------+------------------------+------------------------+
+>| INTEGRATOR_RZ0 | rz0 | Initial guess for the |
+>| | | backwards algebraic |
+>| | | variable . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | casadi::Simu |
+>| | | | uts) (initi | latorInterna |
+>| | | | al|step) | l |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>>List of available monitors
+>
+>+---------+---------------------------+
+>| Id | Used in |
+>+=========+===========================+
+>| initial | casadi::SimulatorInternal |
+>+---------+---------------------------+
+>| inputs | casadi::FunctionInternal |
+>+---------+---------------------------+
+>| outputs | casadi::FunctionInternal |
+>+---------+---------------------------+
+>| step | casadi::SimulatorInternal |
+>+---------+---------------------------+
+>
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: simulator.hpp
+-}
+newtype Simulator = Simulator (ForeignPtr Simulator')
+-- typeclass decl
+class SimulatorClass a where
+ castSimulator :: a -> Simulator
+instance SimulatorClass Simulator where
+ castSimulator = id
+
+-- baseclass instances
+instance FunctionClass Simulator where
+ castFunction (Simulator x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass Simulator where
+ castOptionsFunctionality (Simulator x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass Simulator where
+ castSharedObject (Simulator x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass Simulator where
+ castIOInterfaceFunction (Simulator x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Simulator (Ptr Simulator') where
+ marshal (Simulator x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Simulator x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Simulator"
+ c_delete_casadi__Simulator :: FunPtr (Ptr Simulator' -> IO ())
+instance WrapReturn (Ptr Simulator') Simulator where
+ wrapReturn = (fmap Simulator) . (newForeignPtr c_delete_casadi__Simulator)
+
+
+-- raw decl
+data Slice'
+-- data decl
+{-|
+>Class representing a Slice.
+>
+>Note that Python or Octave do not need to use this class. They can just use
+>slicing utility from the host language ( M[0:6] in Python, M(1:7) )
+>
+>C++ includes: slice.hpp
+-}
+newtype Slice = Slice (ForeignPtr Slice')
+-- typeclass decl
+class SliceClass a where
+ castSlice :: a -> Slice
+instance SliceClass Slice where
+ castSlice = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal Slice (Ptr Slice') where
+ marshal (Slice x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Slice x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Slice"
+ c_delete_casadi__Slice :: FunPtr (Ptr Slice' -> IO ())
+instance WrapReturn (Ptr Slice') Slice where
+ wrapReturn = (fmap Slice) . (newForeignPtr c_delete_casadi__Slice)
+
+
+-- raw decl
+data SocpSolver'
+-- data decl
+{-|
+>SocpSolver.
+>
+>Solves an Second Order Cone Programming (SOCP) problem in standard form.
+>
+>Primal:
+>
+>
+>
+>::
+>
+> min c' x
+> x
+> subject to
+> || Gi' x + hi ||_2 <= ei' x + fi i = 1..m
+>
+> LBA <= A x <= UBA
+> LBX <= x <= UBX
+>
+> with x ( n x 1)
+> c ( n x 1 )
+> Gi sparse (n x ni)
+> hi dense (ni x 1)
+> ei dense (n x 1)
+> fi dense (1 x 1)
+> N = Sum_i^m ni
+> A sparse (nc x n)
+> LBA, UBA dense vector (nc x 1)
+> LBX, UBX dense vector (n x 1)
+>
+>
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::SOCPInput (SOCP_SOLVER_NUM_IN = 10) [socpIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| SOCP_SOLVER_G | g | The horizontal stack |
+>| | | of all matrices Gi: ( |
+>| | | n x N) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_H | h | The vertical stack of |
+>| | | all vectors hi: ( N x |
+>| | | 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_E | e | The vertical stack of |
+>| | | all vectors ei: ( nm x |
+>| | | 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_F | f | The vertical stack of |
+>| | | all scalars fi: ( m x |
+>| | | 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_C | c | The vector c: ( n x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_A | a | The matrix A: ( nc x |
+>| | | n) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_LBA | lba | Lower bounds on Ax ( |
+>| | | nc x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_UBA | uba | Upper bounds on Ax ( |
+>| | | nc x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_LBX | lbx | Lower bounds on x ( n |
+>| | | x 1 ) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_UBX | ubx | Upper bounds on x ( n |
+>| | | x 1 ) . |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::SOCPOutput (SOCP_SOLVER_NUM_OUT = 4) [socpOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| SOCP_SOLVER_X | x | The primal solution (n |
+>| | | x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_COST | cost | The primal optimal |
+>| | | cost (1 x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_LAM_A | lam_a | The dual solution |
+>| | | corresponding to the |
+>| | | linear constraints (nc |
+>| | | x 1) . |
+>+------------------------+------------------------+------------------------+
+>| SOCP_SOLVER_LAM_X | lam_x | The dual solution |
+>| | | corresponding to |
+>| | | simple bounds (n x 1) |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| ni | OT_INTEGERVE | GenericType( | Provide the | casadi::Socp |
+>| | CTOR | ) | size of each | SolverIntern |
+>| | | | SOC | al |
+>| | | | constraint. | |
+>| | | | Must sum up | |
+>| | | | to N. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| print_proble | OT_BOOLEAN | false | Print out | casadi::Socp |
+>| m | | | problem | SolverIntern |
+>| | | | statement | al |
+>| | | | for | |
+>| | | | debugging. | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- sdp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>SocpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>sdp
+>---
+>
+>
+>
+>Solve SOCPs using an SdpSolver
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>>List of available stats
+>
+>+------------------+
+>| Id |
+>+==================+
+>| sdp_solver_stats |
+>+------------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joris Gillis
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: socp_solver.hpp
+-}
+newtype SocpSolver = SocpSolver (ForeignPtr SocpSolver')
+-- typeclass decl
+class SocpSolverClass a where
+ castSocpSolver :: a -> SocpSolver
+instance SocpSolverClass SocpSolver where
+ castSocpSolver = id
+
+-- baseclass instances
+instance FunctionClass SocpSolver where
+ castFunction (SocpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass SocpSolver where
+ castOptionsFunctionality (SocpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass SocpSolver where
+ castSharedObject (SocpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass SocpSolver where
+ castIOInterfaceFunction (SocpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal SocpSolver (Ptr SocpSolver') where
+ marshal (SocpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (SocpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__SocpSolver"
+ c_delete_casadi__SocpSolver :: FunPtr (Ptr SocpSolver' -> IO ())
+instance WrapReturn (Ptr SocpSolver') SocpSolver where
+ wrapReturn = (fmap SocpSolver) . (newForeignPtr c_delete_casadi__SocpSolver)
+
+
+-- raw decl
+data Sparsity'
+-- data decl
+{-|
+>General sparsity class.
+>
+>The storage format is a compressed column storage (CCS) format. In this
+>format, the structural non-zero elements are stored in column-major order,
+>starting from the upper left corner of the matrix and ending in the lower
+>right corner.
+>
+>In addition to the dimension ( size1(), size2()), (i.e. the number of rows
+>and the number of columns respectively), there are also two vectors of
+>integers:
+>
+>"colind" [length size2()+1], which contains the index to the first non-
+>zero element on or after the corresponding column. All the non-zero elements
+>of a particular i are thus the elements with index el that fulfills:
+>colind[i] <= el < colind[i+1].
+>
+>"row" [same length as the number of non-zero elements, size()] The rows
+>for each of the structural non-zeros.
+>
+>Note that with this format, it is cheap to loop over all the non-zero
+>elements of a particular column, at constant time per element, but expensive
+>to jump to access a location (i, j).
+>
+>If the matrix is dense, i.e. length(row) == size1()*size2(), the format
+>reduces to standard dense column major format, which allows access to an
+>arbitrary element in constant time.
+>
+>Since the object is reference counted (it inherits from SharedObject),
+>several matrices are allowed to share the same sparsity pattern.
+>
+>The implementations of some methods of this class has been taken from the
+>CSparse package and modified to use C++ standard library and CasADi data
+>structures.
+>
+>See: Matrix
+>
+>Joel Andersson
+>
+>C++ includes: sparsity.hpp
+-}
+newtype Sparsity = Sparsity (ForeignPtr Sparsity')
+-- typeclass decl
+class SparsityClass a where
+ castSparsity :: a -> Sparsity
+instance SparsityClass Sparsity where
+ castSparsity = id
+
+-- baseclass instances
+instance SharedObjectClass Sparsity where
+ castSharedObject (Sparsity x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal Sparsity (Ptr Sparsity') where
+ marshal (Sparsity x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Sparsity x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Sparsity"
+ c_delete_casadi__Sparsity :: FunPtr (Ptr Sparsity' -> IO ())
+instance WrapReturn (Ptr Sparsity') Sparsity where
+ wrapReturn = (fmap Sparsity) . (newForeignPtr c_delete_casadi__Sparsity)
+
+
+-- raw decl
+data StabilizedQpSolver'
+-- data decl
+{-|
+>StabilizedQpSolver.
+>
+>Solves the following strictly convex problem:
+>
+>
+>
+>::
+>
+> min 1/2 x' H x + g' x
+> x
+>
+> subject to
+> LBA <= A x <= UBA
+> LBX <= x <= UBX
+>
+> with :
+> H sparse (n x n) positive definite
+> g dense (n x 1)
+>
+> n: number of decision variables (x)
+> nc: number of constraints (A)
+>
+>
+>
+>If H is not positive-definite, the solver should throw an error.
+>
+>General information
+>===================
+>
+>
+>
+>>Input scheme: casadi::StabilizedQpSolverInput (STABILIZED_QP_SOLVER_NUM_IN = 12) [stabilizedQpIn]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| STABILIZED_QP_SOLVER_H | h | The square matrix H: |
+>| | | sparse, (n x n). Only |
+>| | | the lower triangular |
+>| | | part is actually used. |
+>| | | The matrix is assumed |
+>| | | to be symmetrical. |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_G | g | The vector g: dense, |
+>| | | (n x 1) . |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_A | a | The matrix A: sparse, |
+>| | | (nc x n) - product |
+>| | | with x must be dense. |
+>| | | . |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_L | lba | dense, (nc x 1) |
+>| BA | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_U | uba | dense, (nc x 1) |
+>| BA | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_L | lbx | dense, (n x 1) |
+>| BX | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_U | ubx | dense, (n x 1) |
+>| BX | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_X | x0 | dense, (n x 1) |
+>| 0 | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_L | lam_x0 | dense |
+>| AM_X0 | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_M | muR | dense (1 x 1) |
+>| UR | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_M | muE | dense (nc x 1) |
+>| UE | | |
+>+------------------------+------------------------+------------------------+
+>| STABILIZED_QP_SOLVER_M | mu | dense (nc x 1) |
+>| U | | |
+>+------------------------+------------------------+------------------------+
+>
+>>Output scheme: casadi::QpSolverOutput (QP_SOLVER_NUM_OUT = 4) [qpOut]
+>
+>+------------------------+------------------------+------------------------+
+>| Full name | Short | Description |
+>+========================+========================+========================+
+>| QP_SOLVER_X | x | The primal solution . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_COST | cost | The optimal cost . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_LAM_A | lam_a | The dual solution |
+>| | | corresponding to |
+>| | | linear bounds . |
+>+------------------------+------------------------+------------------------+
+>| QP_SOLVER_LAM_X | lam_x | The dual solution |
+>| | | corresponding to |
+>| | | simple bounds . |
+>+------------------------+------------------------+------------------------+
+>
+>>List of available options
+>
+>+--------------+--------------+--------------+--------------+--------------+
+>| Id | Type | Default | Description | Used in |
+>+==============+==============+==============+==============+==============+
+>| ad_mode | OT_STRING | "automatic" | How to | casadi::Func |
+>| | | | calculate | tionInternal |
+>| | | | the | |
+>| | | | Jacobians. | |
+>| | | | (forward: | |
+>| | | | only forward | |
+>| | | | mode|reverse | |
+>| | | | : only | |
+>| | | | adjoint mode | |
+>| | | | |automatic: | |
+>| | | | a heuristic | |
+>| | | | decides | |
+>| | | | which is | |
+>| | | | more | |
+>| | | | appropriate) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| derivative_g | OT_DERIVATIV | GenericType( | Function | casadi::Func |
+>| enerator | EGENERATOR | ) | that returns | tionInternal |
+>| | | | a derivative | |
+>| | | | function | |
+>| | | | given a | |
+>| | | | number of | |
+>| | | | forward and | |
+>| | | | reverse | |
+>| | | | directional | |
+>| | | | derivative, | |
+>| | | | overrides | |
+>| | | | internal | |
+>| | | | routines. | |
+>| | | | Check docume | |
+>| | | | ntation of D | |
+>| | | | erivativeGen | |
+>| | | | erator . | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| gather_stats | OT_BOOLEAN | false | Flag to | casadi::Func |
+>| | | | indicate | tionInternal |
+>| | | | whether | |
+>| | | | statistics | |
+>| | | | must be | |
+>| | | | gathered | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| inputs_check | OT_BOOLEAN | true | Throw | casadi::Func |
+>| | | | exceptions | tionInternal |
+>| | | | when the | |
+>| | | | numerical | |
+>| | | | values of | |
+>| | | | the inputs | |
+>| | | | don't make | |
+>| | | | sense | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| monitor | OT_STRINGVEC | GenericType( | Monitors to | casadi::Func |
+>| | TOR | ) | be activated | tionInternal |
+>| | | | (inputs|outp | |
+>| | | | uts) | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| name | OT_STRING | "unnamed_sha | name of the | casadi::Opti |
+>| | | red_object" | object | onsFunctiona |
+>| | | | | lityNode |
+>+--------------+--------------+--------------+--------------+--------------+
+>| regularity_c | OT_BOOLEAN | true | Throw | casadi::Func |
+>| heck | | | exceptions | tionInternal |
+>| | | | when NaN or | |
+>| | | | Inf appears | |
+>| | | | during | |
+>| | | | evaluation | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| user_data | OT_VOIDPTR | GenericType( | A user- | casadi::Func |
+>| | | ) | defined | tionInternal |
+>| | | | field that | |
+>| | | | can be used | |
+>| | | | to identify | |
+>| | | | the function | |
+>| | | | or pass | |
+>| | | | additional | |
+>| | | | information | |
+>+--------------+--------------+--------------+--------------+--------------+
+>| verbose | OT_BOOLEAN | false | Verbose | casadi::Func |
+>| | | | evaluation | tionInternal |
+>| | | | for | |
+>| | | | debugging | |
+>+--------------+--------------+--------------+--------------+--------------+
+>
+>List of plugins
+>===============
+>
+>
+>
+>- sqic
+>
+>- qp
+>
+>Note: some of the plugins in this list might not be available on your
+>system. Also, there might be extra plugins available to you that are not
+>listed here. You can obtain their documentation with
+>StabilizedQpSolver.doc("myextraplugin")
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>sqic
+>----
+>
+>
+>
+>Interface to SQIC
+>
+>>List of available options
+>
+>+----+------+---------+-------------+
+>| Id | Type | Default | Description |
+>+====+======+=========+=============+
+>+----+------+---------+-------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>--------------------------------------------------------------------------------
+>
+>qp --
+>
+>
+>
+>Solved a stabilized QP using a standard QP solver
+>
+>>List of available options
+>
+>+-----------------+-----------------+-----------------+-----------------+
+>| Id | Type | Default | Description |
+>+=================+=================+=================+=================+
+>| qp_solver | OT_STRING | GenericType() | The QP solver |
+>| | | | used to solve |
+>| | | | the stabilized |
+>| | | | QPs. |
+>+-----------------+-----------------+-----------------+-----------------+
+>| qp_solver_optio | OT_DICTIONARY | GenericType() | Options to be |
+>| ns | | | passed to the |
+>| | | | QP solver |
+>| | | | instance |
+>+-----------------+-----------------+-----------------+-----------------+
+>
+>>List of available stats
+>
+>+-----------------+
+>| Id |
+>+=================+
+>| qp_solver_stats |
+>+-----------------+
+>
+>--------------------------------------------------------------------------------
+>
+>
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: stabilized_qp_solver.hpp
+-}
+newtype StabilizedQpSolver = StabilizedQpSolver (ForeignPtr StabilizedQpSolver')
+-- typeclass decl
+class StabilizedQpSolverClass a where
+ castStabilizedQpSolver :: a -> StabilizedQpSolver
+instance StabilizedQpSolverClass StabilizedQpSolver where
+ castStabilizedQpSolver = id
+
+-- baseclass instances
+instance FunctionClass StabilizedQpSolver where
+ castFunction (StabilizedQpSolver x) = Function (castForeignPtr x)
+
+instance OptionsFunctionalityClass StabilizedQpSolver where
+ castOptionsFunctionality (StabilizedQpSolver x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass StabilizedQpSolver where
+ castSharedObject (StabilizedQpSolver x) = SharedObject (castForeignPtr x)
+
+instance IOInterfaceFunctionClass StabilizedQpSolver where
+ castIOInterfaceFunction (StabilizedQpSolver x) = IOInterfaceFunction (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal StabilizedQpSolver (Ptr StabilizedQpSolver') where
+ marshal (StabilizedQpSolver x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (StabilizedQpSolver x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__StabilizedQpSolver"
+ c_delete_casadi__StabilizedQpSolver :: FunPtr (Ptr StabilizedQpSolver' -> IO ())
+instance WrapReturn (Ptr StabilizedQpSolver') StabilizedQpSolver where
+ wrapReturn = (fmap StabilizedQpSolver) . (newForeignPtr c_delete_casadi__StabilizedQpSolver)
+
+
+-- raw decl
+data SymbolicNLP'
+-- data decl
+{-|
+>A symbolic NLP representation.
+>
+>Joel Andersson
+>
+>C++ includes: symbolic_nlp.hpp
+-}
+newtype SymbolicNLP = SymbolicNLP (ForeignPtr SymbolicNLP')
+-- typeclass decl
+class SymbolicNLPClass a where
+ castSymbolicNLP :: a -> SymbolicNLP
+instance SymbolicNLPClass SymbolicNLP where
+ castSymbolicNLP = id
+
+-- baseclass instances
+
+-- 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)
+
+
+-- raw decl
+data SymbolicOCP'
+-- data decl
+{-|
+>A flat OCP representation coupled to an XML file.
+>
+>Variables:
+>==========
+>
+>
+>
+>
+>
+>::
+>
+> x: differential states
+> z: algebraic states
+> p : independent parameters
+> t : time
+> u : control signals
+> q : quadrature states
+> y : dependent variables
+>
+>
+>
+>
+>Equations:
+>==========
+>
+>
+>
+>
+>
+>::
+>
+> explicit or implicit ODE: \\\\dot {x} = ode(t, x, z, u, p_free, pi, pd)
+> or 0 = ode(t, x, z,\\\\dot {x}, u, p_free, pi, pd)
+> algebraic equations: 0 = alg(t, x, z, u, p_free, pi, pd)
+> quadratures: \\\\dot {q} = quad(t, x, z, u, p_free, pi, pd)
+> dependent equations: y = dep(t, x, z, u, p_free, pi, pd)
+> initial equations: 0 = initial(t, x, z, u, p_free, pi, pd)
+>
+>
+>
+>
+>Objective function terms:
+>=========================
+>
+>
+>
+>
+>
+>::
+>
+> Mayer terms: \\\\sum {mterm_k}
+> Lagrange terms: \\\\sum {\\\\integral{mterm}}
+>
+>
+>
+>
+>Note that when parsed, all dynamic equations end up in the implicit category
+>"dae". At a later state, the DAE can be reformulated, for example in semi-
+>explicit form, possibly in addition to a set of quadrature states.
+>
+>Usage skeleton:
+>===============
+>
+>
+>
+>Call default constructor SymbolicOCP ocp;
+>
+>Parse an FMI conformant XML file ocp.parseFMI(xml_file_name)
+>
+>Modify/add variables, equations, optimization ...
+>
+>When the optimal control problem is in a suitable form, it is possible to
+>either generate functions for numeric/symbolic evaluation or exporting the
+>OCP formulation into a new FMI conformant XML file. The latter functionality
+>is not yet available.
+>
+>Joel Andersson
+>
+>C++ includes: symbolic_ocp.hpp
+-}
+newtype SymbolicOCP = SymbolicOCP (ForeignPtr SymbolicOCP')
+-- typeclass decl
+class SymbolicOCPClass a where
+ castSymbolicOCP :: a -> SymbolicOCP
+instance SymbolicOCPClass SymbolicOCP where
+ castSymbolicOCP = id
+
+-- 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)
+
+
+-- raw decl
+data Variable'
+-- data decl
+{-|
+>Holds expressions and meta-data corresponding to a physical quantity
+>evolving in time.
+>
+>Joel Andersson
+>
+>C++ includes: variable.hpp
+-}
+newtype Variable = Variable (ForeignPtr Variable')
+-- typeclass decl
+class VariableClass a where
+ castVariable :: a -> Variable
+instance VariableClass Variable where
+ castVariable = id
+
+-- baseclass instances
+
+-- helper instances
+instance Marshal Variable (Ptr Variable') where
+ marshal (Variable x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (Variable x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__Variable"
+ c_delete_casadi__Variable :: FunPtr (Ptr Variable' -> IO ())
+instance WrapReturn (Ptr Variable') Variable where
+ wrapReturn = (fmap Variable) . (newForeignPtr c_delete_casadi__Variable)
+
+
+-- raw decl
+data XmlFile'
+-- data decl
+{-|
+>XML parser Can be used for parsing XML files into CasADi data structures.
+>
+>Joel Andersson
+>Diagrams
+>--------
+>
+>
+>
+>C++ includes: xml_file.hpp
+-}
+newtype XmlFile = XmlFile (ForeignPtr XmlFile')
+-- typeclass decl
+class XmlFileClass a where
+ castXmlFile :: a -> XmlFile
+instance XmlFileClass XmlFile where
+ castXmlFile = id
+
+-- baseclass instances
+instance OptionsFunctionalityClass XmlFile where
+ castOptionsFunctionality (XmlFile x) = OptionsFunctionality (castForeignPtr x)
+
+instance SharedObjectClass XmlFile where
+ castSharedObject (XmlFile x) = SharedObject (castForeignPtr x)
+
+
+-- helper instances
+instance Marshal XmlFile (Ptr XmlFile') where
+ marshal (XmlFile x) = return (unsafeForeignPtrToPtr x)
+ marshalFree (XmlFile x) _ = touchForeignPtr x
+foreign import ccall unsafe "&delete_casadi__XmlFile"
+ c_delete_casadi__XmlFile :: FunPtr (Ptr XmlFile' -> IO ())
+instance WrapReturn (Ptr XmlFile') XmlFile where
+ wrapReturn = (fmap XmlFile) . (newForeignPtr c_delete_casadi__XmlFile)
-- raw decl
diff --git a/Casadi/Core/Enums.hs b/Casadi/Core/Enums.hs
--- a/Casadi/Core/Enums.hs
+++ b/Casadi/Core/Enums.hs
@@ -4,11 +4,24 @@
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(..),
@@ -20,17 +33,20 @@
JacGInput(..),
JacGOutput(..),
LPStruct(..),
+ LR_DLEInput(..),
+ LR_DLEOutput(..),
+ LR_DPLEInput(..),
+ LR_DPLEOutput(..),
LinsolInput(..),
LinsolOutput(..),
LpSolverInput(..),
LpSolverOutput(..),
- MayerInput(..),
+ LrDleStruct(..),
+ LrDpleVecStruct(..),
NLPInput(..),
NLPOutput(..),
NlpSolverInput(..),
NlpSolverOutput(..),
- OCPInput(..),
- OCPOutput(..),
Operation(..),
Opt_type(..),
QCQPStruct(..),
@@ -53,6 +69,7 @@
SparsityType(..),
StabilizedQpSolverInput(..),
Type(..),
+ Variability(..),
) where
@@ -60,6 +77,135 @@
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
@@ -188,6 +334,130 @@
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
@@ -305,12 +575,19 @@
wrapReturn = return . toEnum . fromIntegral
-- EnumDecl: InputOutputScheme
-data InputOutputScheme = SCHEME_ControlSimulatorInput
+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
@@ -321,17 +598,20 @@
| 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_MayerInput
+ | SCHEME_LrDleStruct
+ | SCHEME_LrDpleVecStruct
| SCHEME_NLPInput
| SCHEME_NLPOutput
| SCHEME_NlpSolverInput
| SCHEME_NlpSolverOutput
- | SCHEME_OCPInput
- | SCHEME_OCPOutput
| SCHEME_QCQPStruct
| SCHEME_QPStruct
| SCHEME_QcqpSolverInput
@@ -352,96 +632,116 @@
| SCHEME_StabilizedQpSolverInput
deriving (Show, Eq)
instance Enum InputOutputScheme where
- fromEnum (SCHEME_ControlSimulatorInput) = 3
- fromEnum (SCHEME_ControlledDAEInput) = 2
- fromEnum (SCHEME_DAEInput) = 5
- fromEnum (SCHEME_DAEOutput) = 6
- fromEnum (SCHEME_DPLEInput) = 0
- fromEnum (SCHEME_DPLEOutput) = 1
- fromEnum (SCHEME_GradFInput) = 18
- fromEnum (SCHEME_GradFOutput) = 19
- fromEnum (SCHEME_HNLPInput) = 4
- fromEnum (SCHEME_HessLagInput) = 22
- fromEnum (SCHEME_HessLagOutput) = 23
- fromEnum (SCHEME_IntegratorInput) = 9
- fromEnum (SCHEME_IntegratorOutput) = 10
- fromEnum (SCHEME_JacGInput) = 20
- fromEnum (SCHEME_JacGOutput) = 21
- fromEnum (SCHEME_LPStruct) = 15
- fromEnum (SCHEME_LinsolInput) = 11
- fromEnum (SCHEME_LinsolOutput) = 12
- fromEnum (SCHEME_LpSolverInput) = 13
- fromEnum (SCHEME_LpSolverOutput) = 14
- fromEnum (SCHEME_MayerInput) = 26
- fromEnum (SCHEME_NLPInput) = 16
- fromEnum (SCHEME_NLPOutput) = 17
- fromEnum (SCHEME_NlpSolverInput) = 24
- fromEnum (SCHEME_NlpSolverOutput) = 25
- fromEnum (SCHEME_OCPInput) = 27
- fromEnum (SCHEME_OCPOutput) = 28
- fromEnum (SCHEME_QCQPStruct) = 31
- fromEnum (SCHEME_QPStruct) = 34
- fromEnum (SCHEME_QcqpSolverInput) = 29
- fromEnum (SCHEME_QcqpSolverOutput) = 30
- fromEnum (SCHEME_QpSolverInput) = 32
- fromEnum (SCHEME_QpSolverOutput) = 33
- fromEnum (SCHEME_RDAEInput) = 7
- fromEnum (SCHEME_RDAEOutput) = 8
- fromEnum (SCHEME_SDPInput) = 35
- fromEnum (SCHEME_SDPOutput) = 36
- fromEnum (SCHEME_SDPStruct) = 37
- fromEnum (SCHEME_SDQPInput) = 38
- fromEnum (SCHEME_SDQPOutput) = 39
- fromEnum (SCHEME_SDQPStruct) = 40
- fromEnum (SCHEME_SOCPInput) = 41
- fromEnum (SCHEME_SOCPOutput) = 42
- fromEnum (SCHEME_SOCPStruct) = 43
- fromEnum (SCHEME_StabilizedQpSolverInput) = 44
- toEnum (3) = SCHEME_ControlSimulatorInput
- toEnum (2) = SCHEME_ControlledDAEInput
- toEnum (5) = SCHEME_DAEInput
- toEnum (6) = SCHEME_DAEOutput
- toEnum (0) = SCHEME_DPLEInput
- toEnum (1) = SCHEME_DPLEOutput
- toEnum (18) = SCHEME_GradFInput
- toEnum (19) = SCHEME_GradFOutput
- toEnum (4) = SCHEME_HNLPInput
- toEnum (22) = SCHEME_HessLagInput
- toEnum (23) = SCHEME_HessLagOutput
- toEnum (9) = SCHEME_IntegratorInput
- toEnum (10) = SCHEME_IntegratorOutput
- toEnum (20) = SCHEME_JacGInput
- toEnum (21) = SCHEME_JacGOutput
- toEnum (15) = SCHEME_LPStruct
- toEnum (11) = SCHEME_LinsolInput
- toEnum (12) = SCHEME_LinsolOutput
- toEnum (13) = SCHEME_LpSolverInput
- toEnum (14) = SCHEME_LpSolverOutput
- toEnum (26) = SCHEME_MayerInput
- toEnum (16) = SCHEME_NLPInput
- toEnum (17) = SCHEME_NLPOutput
- toEnum (24) = SCHEME_NlpSolverInput
- toEnum (25) = SCHEME_NlpSolverOutput
- toEnum (27) = SCHEME_OCPInput
- toEnum (28) = SCHEME_OCPOutput
- toEnum (31) = SCHEME_QCQPStruct
- toEnum (34) = SCHEME_QPStruct
- toEnum (29) = SCHEME_QcqpSolverInput
- toEnum (30) = SCHEME_QcqpSolverOutput
- toEnum (32) = SCHEME_QpSolverInput
- toEnum (33) = SCHEME_QpSolverOutput
- toEnum (7) = SCHEME_RDAEInput
- toEnum (8) = SCHEME_RDAEOutput
- toEnum (35) = SCHEME_SDPInput
- toEnum (36) = SCHEME_SDPOutput
- toEnum (37) = SCHEME_SDPStruct
- toEnum (38) = SCHEME_SDQPInput
- toEnum (39) = SCHEME_SDQPOutput
- toEnum (40) = SCHEME_SDQPStruct
- toEnum (41) = SCHEME_SOCPInput
- toEnum (42) = SCHEME_SOCPOutput
- toEnum (43) = SCHEME_SOCPStruct
- toEnum (44) = SCHEME_StabilizedQpSolverInput
+ 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
@@ -571,6 +871,88 @@
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
@@ -663,25 +1045,57 @@
instance WrapReturn CInt LpSolverOutput where
wrapReturn = return . toEnum . fromIntegral
--- EnumDecl: MayerInput
-data MayerInput = MAYER_NUM_IN
- | MAYER_P
- | MAYER_X
- deriving (Show, Eq)
-instance Enum MayerInput where
- fromEnum (MAYER_NUM_IN) = 2
- fromEnum (MAYER_P) = 1
- fromEnum (MAYER_X) = 0
- toEnum (2) = MAYER_NUM_IN
- toEnum (1) = MAYER_P
- toEnum (0) = MAYER_X
+-- 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 $ "MayerInput: toEnum: got unhandled number: " ++ show k
-instance Marshal MayerInput CInt where
+ = error $ "LrDleStruct: toEnum: got unhandled number: " ++ show k
+instance Marshal LrDleStruct CInt where
marshal = return . fromIntegral . fromEnum
-instance WrapReturn CInt MayerInput where
+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
@@ -790,83 +1204,6 @@
instance WrapReturn CInt NlpSolverOutput where
wrapReturn = return . toEnum . fromIntegral
--- EnumDecl: OCPInput
-data OCPInput = OCP_LBG
- | OCP_LBH
- | OCP_LBP
- | OCP_LBU
- | OCP_LBX
- | OCP_NUM_IN
- | OCP_P_INIT
- | OCP_UBG
- | OCP_UBH
- | OCP_UBP
- | OCP_UBU
- | OCP_UBX
- | OCP_U_INIT
- | OCP_X_INIT
- deriving (Show, Eq)
-instance Enum OCPInput where
- fromEnum (OCP_LBG) = 11
- fromEnum (OCP_LBH) = 9
- fromEnum (OCP_LBP) = 6
- fromEnum (OCP_LBU) = 3
- fromEnum (OCP_LBX) = 0
- fromEnum (OCP_NUM_IN) = 13
- fromEnum (OCP_P_INIT) = 8
- fromEnum (OCP_UBG) = 12
- fromEnum (OCP_UBH) = 10
- fromEnum (OCP_UBP) = 7
- fromEnum (OCP_UBU) = 4
- fromEnum (OCP_UBX) = 1
- fromEnum (OCP_U_INIT) = 5
- fromEnum (OCP_X_INIT) = 2
- toEnum (11) = OCP_LBG
- toEnum (9) = OCP_LBH
- toEnum (6) = OCP_LBP
- toEnum (3) = OCP_LBU
- toEnum (0) = OCP_LBX
- toEnum (13) = OCP_NUM_IN
- toEnum (8) = OCP_P_INIT
- toEnum (12) = OCP_UBG
- toEnum (10) = OCP_UBH
- toEnum (7) = OCP_UBP
- toEnum (4) = OCP_UBU
- toEnum (1) = OCP_UBX
- toEnum (5) = OCP_U_INIT
- toEnum (2) = OCP_X_INIT
- toEnum k
- = error $ "OCPInput: toEnum: got unhandled number: " ++ show k
-instance Marshal OCPInput CInt where
- marshal = return . fromIntegral . fromEnum
-instance WrapReturn CInt OCPInput where
- wrapReturn = return . toEnum . fromIntegral
-
--- EnumDecl: OCPOutput
-data OCPOutput = OCP_COST
- | OCP_NUM_OUT
- | OCP_P_OPT
- | OCP_U_OPT
- | OCP_X_OPT
- deriving (Show, Eq)
-instance Enum OCPOutput where
- fromEnum (OCP_COST) = 3
- fromEnum (OCP_NUM_OUT) = 4
- fromEnum (OCP_P_OPT) = 2
- fromEnum (OCP_U_OPT) = 1
- fromEnum (OCP_X_OPT) = 0
- toEnum (3) = OCP_COST
- toEnum (4) = OCP_NUM_OUT
- toEnum (2) = OCP_P_OPT
- toEnum (1) = OCP_U_OPT
- toEnum (0) = OCP_X_OPT
- toEnum k
- = error $ "OCPOutput: toEnum: got unhandled number: " ++ show k
-instance Marshal OCPOutput CInt where
- marshal = return . fromIntegral . fromEnum
-instance WrapReturn CInt OCPOutput where
- wrapReturn = return . toEnum . fromIntegral
-
-- EnumDecl: Operation
data Operation = NUM_BUILT_IN_OPS
| OP_ACOS
@@ -889,6 +1226,8 @@
| OP_COS
| OP_COSH
| OP_DETERMINANT
+ | OP_DIAGCAT
+ | OP_DIAGSPLIT
| OP_DIV
| OP_EQ
| OP_ERF
@@ -945,15 +1284,15 @@
| OP_VERTSPLIT
deriving (Show, Eq)
instance Enum Operation where
- fromEnum (NUM_BUILT_IN_OPS) = 74
+ fromEnum (NUM_BUILT_IN_OPS) = 76
fromEnum (OP_ACOS) = 17
fromEnum (OP_ACOSH) = 41
fromEnum (OP_ADD) = 1
- fromEnum (OP_ADDNONZEROS) = 63
+ fromEnum (OP_ADDNONZEROS) = 65
fromEnum (OP_AND) = 24
fromEnum (OP_ASIN) = 16
fromEnum (OP_ASINH) = 40
- fromEnum (OP_ASSERTION) = 66
+ fromEnum (OP_ASSERTION) = 68
fromEnum (OP_ASSIGN) = 0
fromEnum (OP_ATAN) = 18
fromEnum (OP_ATAN2) = 43
@@ -966,45 +1305,47 @@
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) = 71
+ 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) = 62
+ fromEnum (OP_GETNONZEROS) = 64
fromEnum (OP_HORZCAT) = 55
- fromEnum (OP_HORZSPLIT) = 57
+ 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) = 73
+ 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) = 68
- fromEnum (OP_NORM2) = 67
- fromEnum (OP_NORMF) = 70
- fromEnum (OP_NORMINF) = 69
+ 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) = 72
- fromEnum (OP_RESHAPE) = 59
- fromEnum (OP_SETNONZEROS) = 64
- fromEnum (OP_SET_SPARSE) = 65
+ 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
@@ -1012,23 +1353,23 @@
fromEnum (OP_SQ) = 11
fromEnum (OP_SQRT) = 10
fromEnum (OP_SUB) = 2
- fromEnum (OP_SUBASSIGN) = 61
- fromEnum (OP_SUBREF) = 60
+ 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) = 58
- toEnum (74) = NUM_BUILT_IN_OPS
+ fromEnum (OP_VERTSPLIT) = 59
+ toEnum (76) = NUM_BUILT_IN_OPS
toEnum (17) = OP_ACOS
toEnum (41) = OP_ACOSH
toEnum (1) = OP_ADD
- toEnum (63) = OP_ADDNONZEROS
+ toEnum (65) = OP_ADDNONZEROS
toEnum (24) = OP_AND
toEnum (16) = OP_ASIN
toEnum (40) = OP_ASINH
- toEnum (66) = OP_ASSERTION
+ toEnum (68) = OP_ASSERTION
toEnum (0) = OP_ASSIGN
toEnum (18) = OP_ATAN
toEnum (43) = OP_ATAN2
@@ -1041,45 +1382,47 @@
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 (71) = OP_ERFINV
+ 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 (62) = OP_GETNONZEROS
+ toEnum (64) = OP_GETNONZEROS
toEnum (55) = OP_HORZCAT
- toEnum (57) = OP_HORZSPLIT
+ 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 (73) = OP_LIFT
+ 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 (68) = OP_NORM1
- toEnum (67) = OP_NORM2
- toEnum (70) = OP_NORMF
- toEnum (69) = OP_NORMINF
+ 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 (72) = OP_PRINTME
- toEnum (59) = OP_RESHAPE
- toEnum (64) = OP_SETNONZEROS
- toEnum (65) = OP_SET_SPARSE
+ 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
@@ -1087,14 +1430,14 @@
toEnum (11) = OP_SQ
toEnum (10) = OP_SQRT
toEnum (2) = OP_SUB
- toEnum (61) = OP_SUBASSIGN
- toEnum (60) = OP_SUBREF
+ 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 (58) = OP_VERTSPLIT
+ toEnum (59) = OP_VERTSPLIT
toEnum k
= error $ "Operation: toEnum: got unhandled number: " ++ show k
instance Marshal Operation CInt where
@@ -1714,6 +2057,28 @@
instance Marshal Type CInt where
marshal = return . fromIntegral . fromEnum
instance WrapReturn CInt Type 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
diff --git a/Casadi/Core/Tools.hs b/Casadi/Core/Tools.hs
--- a/Casadi/Core/Tools.hs
+++ b/Casadi/Core/Tools.hs
@@ -20,21592 +20,27276 @@
blockcat__1,
blockcat__2,
blockcat__3,
- blocksplit__0,
- blocksplit__1,
- blocksplit__10,
- blocksplit__11,
- blocksplit__12,
- blocksplit__13,
- blocksplit__14,
- blocksplit__15,
- blocksplit__2,
- blocksplit__3,
- blocksplit__4,
- blocksplit__5,
- blocksplit__6,
- blocksplit__7,
- blocksplit__8,
- blocksplit__9,
- cofactor__0,
- cofactor__1,
- cofactor__2,
- collocationPoints__0,
- collocationPoints__1,
- complement,
- compress__0,
- compress__1,
- 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__4,
- controldaeIn__5,
- controldaeIn__6,
- controldaeIn__7,
- controldaeIn__8,
- controldaeIn__9,
- controlsimulatorIn__0,
- controlsimulatorIn__1,
- controlsimulatorIn__10,
- controlsimulatorIn__11,
- 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,
- cross__0,
- cross__1,
- cross__2,
- cross__3,
- cross__4,
- cross__5,
- cross__6,
- cross__7,
- daeIn__0,
- daeIn__1,
- daeIn__10,
- daeIn__11,
- daeIn__12,
- daeIn__13,
- daeIn__14,
- 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__2,
- daeOut__3,
- daeOut__4,
- daeOut__5,
- daeOut__6,
- daeOut__7,
- daeOut__8,
- daeOut__9,
- dense__0,
- dense__1,
- dense__2,
- dense__3,
- dependsOn__0,
- dependsOn__1,
- det__0,
- det__1,
- det__2,
- det__3,
- diag__0,
- diag__1,
- diag__2,
- diag__3,
- dpleIn__0,
- dpleIn__1,
- dpleIn__2,
- dpleIn__3,
- dpleIn__4,
- dpleIn__5,
- dpleIn__6,
- dpleIn__7,
- dpleIn__8,
- dpleOut__0,
- dpleOut__1,
- dpleOut__2,
- dpleOut__3,
- dpleOut__4,
- dpleOut__5,
- eig_symbolic,
- evalf__0,
- evalf__1,
- expand,
- explicitRK__0,
- explicitRK__1,
- explicitRK__2,
- explicitRK__3,
- extractShared__0,
- extractShared__1,
- extractShared__2,
- extractShared__3,
- extractShared__4,
- extractShared__5,
- gauss_quadrature__0,
- gauss_quadrature__1,
- gauss_quadrature__2,
- getFree,
- getMinor__0,
- getMinor__1,
- getMinor__2,
- getOperatorRepresentation__0,
- getOperatorRepresentation__1,
- getSchemeEntryDoc,
- getSchemeEntryEnum,
- getSchemeEntryEnumName,
- getSchemeEntryName,
- getSchemeEntryNames,
- getSchemeName,
- getSchemeSize,
- getSymbols__0,
- getSymbols__1,
- getSymbols__2,
- gradFIn__0,
- gradFIn__1,
- gradFIn__2,
- gradFIn__3,
- gradFIn__4,
- gradFIn__5,
- gradFIn__6,
- gradFIn__7,
- gradFIn__8,
- gradFOut__0,
- gradFOut__1,
- gradFOut__10,
- gradFOut__11,
- 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__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__2,
- hessLagOut__3,
- hessLagOut__4,
- hessLagOut__5,
- hessLagOut__6,
- hessLagOut__7,
- hessLagOut__8,
- hessLagOut__9,
- hessian__0,
- hessian__1,
- hnlpIn__0,
- hnlpIn__1,
- hnlpIn__10,
- hnlpIn__11,
- hnlpIn__2,
- hnlpIn__3,
- hnlpIn__4,
- hnlpIn__5,
- hnlpIn__6,
- hnlpIn__7,
- hnlpIn__8,
- hnlpIn__9,
- horzcat__0,
- horzcat__1,
- horzcat__2,
- horzcat__3,
- horzcat__4,
- horzsplit__0,
- horzsplit__1,
- horzsplit__10,
- horzsplit__11,
- horzsplit__12,
- horzsplit__2,
- horzsplit__3,
- horzsplit__4,
- horzsplit__5,
- horzsplit__6,
- horzsplit__7,
- horzsplit__8,
- horzsplit__9,
- if_else__0,
- if_else__1,
- implicitRK,
- inner_prod__0,
- inner_prod__1,
- inner_prod__2,
- inner_prod__3,
- 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__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__3,
- integratorOut__4,
- integratorOut__5,
- integratorOut__6,
- integratorOut__7,
- integratorOut__8,
- integratorOut__9,
- inv__0,
- inv__1,
- inv__2,
- inv__3,
- isDecreasing__0,
- isDecreasing__1,
- isEqual__0,
- isEqual__1,
- isEqual__2,
- isEqual__3,
- 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__2,
- jacGIn__3,
- jacGIn__4,
- jacGIn__5,
- jacGIn__6,
- jacGIn__7,
- jacGIn__8,
- jacGOut__0,
- jacGOut__1,
- jacGOut__10,
- jacGOut__11,
- jacGOut__2,
- jacGOut__3,
- jacGOut__4,
- jacGOut__5,
- jacGOut__6,
- jacGOut__7,
- jacGOut__8,
- jacGOut__9,
- jacobianTimesVector__0,
- jacobianTimesVector__1,
- jacobian__0,
- jacobian__1,
- kron__0,
- kron__1,
- kron__2,
- kron__3,
- linsolIn__0,
- linsolIn__1,
- linsolIn__2,
- linsolIn__3,
- linsolIn__4,
- linsolIn__5,
- linsolIn__6,
- linsolIn__7,
- linsolIn__8,
- linsolOut__0,
- linsolOut__1,
- linsolOut__2,
- linsolOut__3,
- linsolOut__4,
- linsolOut__5,
- linspace__0,
- linspace__1,
- linspace__2,
- logic_and__0,
- logic_and__1,
- logic_and__2,
- logic_and__3,
- logic_and__4,
- logic_and__5,
- logic_and__6,
- logic_not__0,
- logic_not__1,
- logic_not__2,
- logic_not__3,
- logic_not__4,
- logic_not__5,
- logic_not__6,
- logic_or__0,
- logic_or__1,
- logic_or__2,
- logic_or__3,
- logic_or__4,
- logic_or__5,
- logic_or__6,
- 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__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__2,
- lpOut__3,
- lpOut__4,
- lpOut__5,
- lpOut__6,
- lpOut__7,
- lpOut__8,
- lpOut__9,
- lpStruct__0,
- lpStruct__1,
- matrix_expand__0,
- matrix_expand__1,
- matrix_expand__2,
- matrix_expand__3,
- mayerIn__0,
- mayerIn__1,
- mayerIn__2,
- mayerIn__3,
- mayerIn__4,
- mayerIn__5,
- mayerIn__6,
- mayerIn__7,
- mayerIn__8,
- mtaylor__0,
- mtaylor__1,
- mtaylor__2,
- mul__0,
- mul__1,
- mul__10,
- mul__11,
- mul__12,
- mul__2,
- mul__3,
- mul__4,
- mul__5,
- mul__6,
- mul__7,
- mul__8,
- mul__9,
- nlpIn__0,
- nlpIn__1,
- nlpIn__2,
- nlpIn__3,
- nlpIn__4,
- nlpIn__5,
- nlpIn__6,
- nlpIn__7,
- nlpIn__8,
- nlpOut__0,
- nlpOut__1,
- 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__3,
- 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__3,
- nlpSolverOut__4,
- nlpSolverOut__5,
- nlpSolverOut__6,
- nlpSolverOut__7,
- nlpSolverOut__8,
- nlpSolverOut__9,
- norm_1__0,
- norm_1__1,
- norm_1__2,
- norm_1__3,
- norm_2__0,
- norm_2__1,
- norm_2__2,
- norm_2__3,
- norm_F__0,
- norm_F__1,
- norm_F__2,
- norm_F__3,
- norm_inf__0,
- norm_inf__1,
- norm_inf__2,
- norm_inf__3,
- nullspace__0,
- nullspace__1,
- nullspace__2,
- nullspace__3,
- ocpIn__0,
- ocpIn__1,
- ocpIn__10,
- ocpIn__11,
- ocpIn__12,
- ocpIn__13,
- ocpIn__14,
- ocpIn__15,
- ocpIn__16,
- ocpIn__17,
- ocpIn__18,
- ocpIn__19,
- ocpIn__2,
- ocpIn__20,
- ocpIn__21,
- ocpIn__22,
- ocpIn__23,
- ocpIn__24,
- ocpIn__25,
- ocpIn__26,
- ocpIn__27,
- ocpIn__28,
- ocpIn__29,
- ocpIn__3,
- ocpIn__30,
- ocpIn__31,
- ocpIn__32,
- ocpIn__33,
- ocpIn__34,
- ocpIn__35,
- ocpIn__36,
- ocpIn__37,
- ocpIn__38,
- ocpIn__39,
- ocpIn__4,
- ocpIn__40,
- ocpIn__41,
- ocpIn__5,
- ocpIn__6,
- ocpIn__7,
- ocpIn__8,
- ocpIn__9,
- ocpOut__0,
- ocpOut__1,
- ocpOut__10,
- ocpOut__11,
- ocpOut__12,
- ocpOut__13,
- ocpOut__14,
- ocpOut__2,
- ocpOut__3,
- ocpOut__4,
- ocpOut__5,
- ocpOut__6,
- ocpOut__7,
- ocpOut__8,
- ocpOut__9,
- outer_prod__0,
- outer_prod__1,
- outer_prod__2,
- outer_prod__3,
- pinv__0,
- pinv__1,
- pinv__2,
- pinv__3,
- pinv__4,
- poly_coeff,
- poly_roots,
- polyval__0,
- polyval__1,
- polyval__2,
- polyval__3,
- printCompact__0,
- printCompact__1,
- project__0,
- project__1,
- project__2,
- 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__4,
- qcqpIn__5,
- qcqpIn__6,
- qcqpIn__7,
- qcqpIn__8,
- qcqpIn__9,
- qcqpOut__0,
- qcqpOut__1,
- qcqpOut__10,
- qcqpOut__11,
- qcqpOut__12,
- qcqpOut__13,
- qcqpOut__14,
- 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__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__2,
- qpOut__3,
- qpOut__4,
- qpOut__5,
- qpOut__6,
- qpOut__7,
- qpOut__8,
- qpOut__9,
- qpStruct__0,
- qpStruct__1,
- qpStruct__2,
- ramp,
- rank,
- 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__3,
- rdaeIn__4,
- rdaeIn__5,
- rdaeIn__6,
- rdaeIn__7,
- rdaeIn__8,
- rdaeIn__9,
- rdaeOut__0,
- rdaeOut__1,
- rdaeOut__10,
- rdaeOut__11,
- rdaeOut__2,
- rdaeOut__3,
- rdaeOut__4,
- rdaeOut__5,
- rdaeOut__6,
- rdaeOut__7,
- rdaeOut__8,
- rdaeOut__9,
- rectangle,
- repmat__0,
- repmat__1,
- repmat__2,
- repmat__3,
- reshape__0,
- reshape__1,
- reshape__2,
- reshape__3,
- reshape__4,
- reshape__5,
- reshape__6,
- reshape__7,
- 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__3,
- 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__3,
- 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__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__3,
- sdqpOut__4,
- sdqpOut__5,
- sdqpOut__6,
- sdqpOut__7,
- sdqpOut__8,
- sdqpOut__9,
- sdqpStruct__0,
- sdqpStruct__1,
- sdqpStruct__2,
- sdqpStruct__3,
- sdqpStruct__4,
- simplify__0,
- simplify__1,
- 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__4,
- 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__2,
- socpOut__3,
- socpOut__4,
- socpOut__5,
- socpOut__6,
- socpOut__7,
- socpOut__8,
- socpOut__9,
- socpStruct__0,
- socpStruct__1,
- socpStruct__2,
- solve__0,
- solve__1,
- solve__2,
- solve__3,
- solve__4,
- solve__5,
- sparse__0,
- sparse__1,
- sparse__2,
- sparse__3,
- sparse__4,
- sparse__5,
- sprank__0,
- sprank__1,
- sprank__2,
- 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__4,
- stabilizedQpIn__5,
- stabilizedQpIn__6,
- stabilizedQpIn__7,
- stabilizedQpIn__8,
- stabilizedQpIn__9,
- substituteInPlace__0,
- substituteInPlace__1,
- substituteInPlace__2,
- substituteInPlace__3,
- substituteInPlace__4,
- substituteInPlace__5,
- substitute__0,
- substitute__1,
- substitute__2,
- substitute__3,
- sumAll__0,
- sumAll__1,
- sumAll__2,
- sumAll__3,
- sumCols__0,
- sumCols__1,
- sumCols__2,
- sumCols__3,
- sumRows__0,
- sumRows__1,
- sumRows__2,
- sumRows__3,
- tangent__0,
- tangent__1,
- taylor__0,
- taylor__1,
- taylor__2,
- trace__0,
- trace__1,
- trace__2,
- trace__3,
- transpose__0,
- transpose__1,
- transpose__2,
- transpose__3,
- transpose__4,
- triangle,
- tril2symm__0,
- tril2symm__1,
- tril2symm__2,
- tril2symm__3,
- tril__0,
- tril__1,
- tril__2,
- tril__3,
- tril__4,
- tril__5,
- triu2symm__0,
- triu2symm__1,
- triu2symm__2,
- triu2symm__3,
- triu__0,
- triu__1,
- triu__2,
- triu__3,
- triu__4,
- triu__5,
- unite__0,
- unite__1,
- unite__2,
- unite__3,
- vecNZ__0,
- vecNZ__1,
- vecNZ__2,
- vecNZ__3,
- vecNZcat__0,
- vecNZcat__1,
- vecNZcat__2,
- vecNZcat__3,
- vec__0,
- vec__1,
- vec__2,
- vec__3,
- vec__4,
- veccat__0,
- veccat__1,
- veccat__2,
- veccat__3,
- vertcat__0,
- vertcat__1,
- vertcat__2,
- vertcat__3,
- vertcat__4,
- vertsplit__0,
- vertsplit__1,
- vertsplit__10,
- vertsplit__11,
- vertsplit__12,
- vertsplit__2,
- vertsplit__3,
- vertsplit__4,
- vertsplit__5,
- vertsplit__6,
- vertsplit__7,
- vertsplit__8,
- vertsplit__9,
- ) 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 "addMultiple__0" c_addMultiple__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> IO ()
-{-|
->same as: res += mul(A, v)
--}
-addMultiple__0
- :: SX -> Vector SXElement -> Vector SXElement -> IO ()
-addMultiple__0 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_addMultiple__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 "addMultiple__1" c_addMultiple__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> CInt -> IO ()
-{-|
->same as: res += mul(A, v)
--}
-addMultiple__1
- :: SX -> Vector SXElement -> Vector SXElement -> Bool -> IO ()
-addMultiple__1 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_addMultiple__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 "addMultiple__2" c_addMultiple__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> IO ()
-{-|
->same as: res += mul(A, v)
--}
-addMultiple__2
- :: DMatrix -> Vector Double -> Vector Double -> IO ()
-addMultiple__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_addMultiple__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 "addMultiple__3" c_addMultiple__3
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> CInt -> IO ()
-{-|
->same as: res += mul(A, v)
--}
-addMultiple__3
- :: DMatrix -> Vector Double -> Vector Double -> Bool -> IO ()
-addMultiple__3 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_addMultiple__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 "addMultiple__4" c_addMultiple__4
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
-{-|
->same as: res += mul(A, v)
--}
-addMultiple__4
- :: IMatrix -> Vector Int -> Vector Int -> IO ()
-addMultiple__4 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_addMultiple__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 "addMultiple__5" c_addMultiple__5
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
-{-|
->same as: res += mul(A, v)
--}
-addMultiple__5
- :: IMatrix -> Vector Int -> Vector Int -> Bool -> IO ()
-addMultiple__5 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_addMultiple__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 "adj__0" c_adj__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-adj__0
- :: SX -> IO SX
-adj__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_adj__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "adj__1" c_adj__1
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-adj__1
- :: DMatrix -> IO DMatrix
-adj__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_adj__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "adj__2" c_adj__2
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-adj__2
- :: IMatrix -> IO IMatrix
-adj__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_adj__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blkdiag__0" c_blkdiag__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-{-|
->Construct a matrix with given blocks on the diagonal.
--}
-blkdiag__0
- :: Vector MX -> IO MX
-blkdiag__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blkdiag__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blkdiag__1" c_blkdiag__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-{-|
->Construct a Sparsity with given blocks on the diagonal.
--}
-blkdiag__1
- :: Vector Sparsity -> IO Sparsity
-blkdiag__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blkdiag__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blkdiag__2" c_blkdiag__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-{-|
->Construct a matrix with given blocks on the diagonal.
->
->Construct a matrix with given block on the diagonal.
--}
-blkdiag__2
- :: Vector SX -> IO SX
-blkdiag__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blkdiag__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blkdiag__3" c_blkdiag__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-{-|
->Construct a matrix with given blocks on the diagonal.
->
->Construct a matrix with given block on the diagonal.
--}
-blkdiag__3
- :: Vector DMatrix -> IO DMatrix
-blkdiag__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blkdiag__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blkdiag__4" c_blkdiag__4
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-{-|
->Construct a matrix with given blocks on the diagonal.
->
->Construct a matrix with given block on the diagonal.
--}
-blkdiag__4
- :: Vector IMatrix -> IO IMatrix
-blkdiag__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blkdiag__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blockcat__0" c_blockcat__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr MX')
-{-|
->Construct a matrix from a list of list of blocks.
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blockcat__0
- :: Vector (Vector MX) -> IO MX
-blockcat__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blockcat__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blockcat__1" c_blockcat__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO (Ptr SX')
-{-|
->Construct a matrix from a list of list of blocks.
--}
-blockcat__1
- :: Vector (Vector SX) -> IO SX
-blockcat__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blockcat__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blockcat__2" c_blockcat__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO (Ptr DMatrix')
-{-|
->Construct a matrix from a list of list of blocks.
--}
-blockcat__2
- :: Vector (Vector DMatrix) -> IO DMatrix
-blockcat__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blockcat__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blockcat__3" c_blockcat__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))) -> IO (Ptr IMatrix')
-{-|
->Construct a matrix from a list of list of blocks.
--}
-blockcat__3
- :: Vector (Vector IMatrix) -> IO IMatrix
-blockcat__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blockcat__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blocksplit__0" c_blocksplit__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in col dimension
->horz_incr Defines the increment for block boundaries in row dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__0
- :: MX -> IO (Vector (Vector MX))
-blocksplit__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blocksplit__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blocksplit__1" c_blocksplit__1
- :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in col dimension
->horz_incr Defines the increment for block boundaries in row dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__1
- :: MX -> Int -> IO (Vector (Vector MX))
-blocksplit__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__2" c_blocksplit__2
- :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in col dimension
->horz_incr Defines the increment for block boundaries in row dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__2
- :: MX -> Int -> Int -> IO (Vector (Vector MX))
-blocksplit__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__3" c_blocksplit__3
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
-{-|
->chop up into blocks
->
->vert_offset Defines the boundaries of the block cols horz_offset Defines the
->boundaries of the block rows
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__3
- :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX))
-blocksplit__3 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__4" c_blocksplit__4
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__4
- :: SX -> IO (Vector (Vector SX))
-blocksplit__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blocksplit__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blocksplit__5" c_blocksplit__5
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__5
- :: SX -> Int -> IO (Vector (Vector SX))
-blocksplit__5 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__6" c_blocksplit__6
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__6
- :: SX -> Int -> Int -> IO (Vector (Vector SX))
-blocksplit__6 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__7" c_blocksplit__7
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
-{-|
->chop up into blocks
->
->vert_offset Defines the boundaries of the block rows horz_offset Defines the
->boundaries of the block columns
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__7
- :: SX -> Vector Int -> Vector Int -> IO (Vector (Vector SX))
-blocksplit__7 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__8" c_blocksplit__8
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__8
- :: DMatrix -> IO (Vector (Vector DMatrix))
-blocksplit__8 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blocksplit__8 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blocksplit__9" c_blocksplit__9
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__9
- :: DMatrix -> Int -> IO (Vector (Vector DMatrix))
-blocksplit__9 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__10" c_blocksplit__10
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__10
- :: DMatrix -> Int -> Int -> IO (Vector (Vector DMatrix))
-blocksplit__10 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__11" c_blocksplit__11
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
-{-|
->chop up into blocks
->
->vert_offset Defines the boundaries of the block rows horz_offset Defines the
->boundaries of the block columns
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__11
- :: DMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix))
-blocksplit__11 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__12" c_blocksplit__12
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__12
- :: IMatrix -> IO (Vector (Vector IMatrix))
-blocksplit__12 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_blocksplit__12 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "blocksplit__13" c_blocksplit__13
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__13
- :: IMatrix -> Int -> IO (Vector (Vector IMatrix))
-blocksplit__13 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__14" c_blocksplit__14
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-{-|
->chop up into blocks
->
->vert_incr Defines the increment for block boundaries in row dimension
->horz_incr Defines the increment for block boundaries in column dimension
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__14
- :: IMatrix -> Int -> Int -> IO (Vector (Vector IMatrix))
-blocksplit__14 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "blocksplit__15" c_blocksplit__15
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
-{-|
->chop up into blocks
->
->vert_offset Defines the boundaries of the block rows horz_offset Defines the
->boundaries of the block columns
->
->blockcat(blocksplit(x,..., ...)) = x
--}
-blocksplit__15
- :: IMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix))
-blocksplit__15 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cofactor__0" c_cofactor__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SXElement')
-cofactor__0
- :: SX -> Int -> Int -> IO SXElement
-cofactor__0 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cofactor__1" c_cofactor__1
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO CDouble
-cofactor__1
- :: DMatrix -> Int -> Int -> IO Double
-cofactor__1 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cofactor__2" c_cofactor__2
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt
-cofactor__2
- :: IMatrix -> Int -> Int -> IO Int
-cofactor__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "collocationPoints__0" c_collocationPoints__0
- :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec CDouble))
-{-|
->Obtain collocation points of specific order and scheme.
->
->Parameters:
->-----------
->
->scheme: 'radau' or 'legendre'
--}
-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))
-{-|
->Obtain collocation points of specific order and scheme.
->
->Parameters:
->-----------
->
->scheme: 'radau' or 'legendre'
--}
-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))
-{-|
->Returns the list of all i in [0, size[ not found in supplied list.
->
->The supplied vector may contain duplicates and may be non-monotonous The
->supplied vector will be checked for bounds The result vector is guaranteed
->to be monotonously increasing
--}
-complement
- :: Vector Int -> Int -> IO (Vector Int)
-complement x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- 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 "compress__0" c_compress__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-{-|
->Remove identical calculations.
--}
-compress__0
- :: SX -> IO ()
-compress__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_compress__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "compress__1" c_compress__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO ()
-{-|
->Remove identical calculations.
--}
-compress__1
- :: SX -> Int -> IO ()
-compress__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_compress__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__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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__10
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__11
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__12
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__13
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__14
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__15
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__16
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__17
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controldaeIn__18
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__19
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__20
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__21
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__22
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__23
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__24
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__25
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__26
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__27
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controldaeIn__28
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__29
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-controlsimulatorIn__4
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controlsimulatorIn__5
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controlsimulatorIn__6
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-controlsimulatorIn__7
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-controlsimulatorIn__8
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controlsimulatorIn__9
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controlsimulatorIn__10
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-controlsimulatorIn__11
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 "countNodes__0" c_countNodes__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO CInt
-{-|
->Count number of nodes
--}
-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
-{-|
->Count number of nodes.
--}
-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')
-{-|
->Create a parent MX on which a bunch of MX's (sizes given as argument) will
->depend.
--}
-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')
-{-|
->Create a parent MX on which a bunch of MX's (sizes given as argument) will
->depend.
--}
-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')
-{-|
->Create a parent MX on which all given MX's will depend.
->
->In some sense, this function is the inverse of
->
->Parameters:
->-----------
->
->deps: Must all be symbolic matrices.
--}
-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 "cross__0" c_cross__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Matlab's cross command.
--}
-cross__0
- :: MX -> MX -> IO MX
-cross__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cross__1" c_cross__1
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
-{-|
->Matlab's cross command.
--}
-cross__1
- :: MX -> MX -> Int -> IO MX
-cross__1 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cross__2" c_cross__2
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Matlab's cross command.
--}
-cross__2
- :: SX -> SX -> IO SX
-cross__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cross__3" c_cross__3
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-{-|
->Matlab's cross command.
--}
-cross__3
- :: SX -> SX -> Int -> IO SX
-cross__3 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cross__4" c_cross__4
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Matlab's cross command.
--}
-cross__4
- :: DMatrix -> DMatrix -> IO DMatrix
-cross__4 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cross__5" c_cross__5
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-{-|
->Matlab's cross command.
--}
-cross__5
- :: DMatrix -> DMatrix -> Int -> IO DMatrix
-cross__5 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cross__6" c_cross__6
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Matlab's cross command.
--}
-cross__6
- :: IMatrix -> IMatrix -> IO IMatrix
-cross__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "cross__7" c_cross__7
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
-{-|
->Matlab's cross command.
--}
-cross__7
- :: IMatrix -> IMatrix -> Int -> IO IMatrix
-cross__7 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-daeIn__5
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-daeIn__6
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-daeIn__7
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-daeIn__8
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-daeIn__9
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-daeIn__10
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-daeIn__11
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-daeIn__12
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-daeIn__13
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-daeIn__14
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-daeOut__4
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-daeOut__5
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-daeOut__6
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-daeOut__7
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-daeOut__8
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-daeOut__9
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-daeOut__10
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-daeOut__11
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 "dense__0" c_dense__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->create a clipped view into a matrix Create a sparse matrix from a dense
->matrix A, with sparsity pattern sp
->
->MX clip(const MX& A, const Sparsity& sp) { Join the sparsity patterns
->std::vector mapping; Sparsity sp = A.sparsity().patternIntersection(sp,
->mapping);
->
->Split up the mapping std::vector nzA, nzB;
->
->Copy sparsity for (int k=0; knzA.push_back(k); } else if (mapping[k]>0) { nzB.push_back(k); } else {
->throw CasadiException("Pattern intersection not empty"); } }
->
->Create mapping MX ret; ret.assignNode(new Mapping(sp)); ret->assign(A,
->range(nzA.size()), nzA); ret->assign(B, range(nzB.size()), nzB); return ret;
->
->}
->
->Make the matrix dense if not already
--}
-dense__0
- :: MX -> IO MX
-dense__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_dense__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dense__1" c_dense__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Make a matrix dense.
--}
-dense__1
- :: SX -> IO SX
-dense__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_dense__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dense__2" c_dense__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Make a matrix dense.
--}
-dense__2
- :: DMatrix -> IO DMatrix
-dense__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_dense__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "dense__3" c_dense__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Make a matrix dense.
--}
-dense__3
- :: IMatrix -> IO IMatrix
-dense__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_dense__3 errStrPtrP x0'
- 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
-{-|
->Check if expression depends on any of the arguments The arguments must be
->symbolic.
--}
-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
-{-|
->Check if expression depends on the argument The argument must be symbolic.
--}
-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 "det__0" c_det__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Matrix determinant (experimental)
--}
-det__0
- :: MX -> IO MX
-det__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_det__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "det__1" c_det__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SXElement')
-det__1
- :: SX -> IO SXElement
-det__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_det__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "det__2" c_det__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CDouble
-det__2
- :: DMatrix -> IO Double
-det__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_det__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "det__3" c_det__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-det__3
- :: IMatrix -> IO Int
-det__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_det__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "diag__0" c_diag__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Get the diagonal of a matrix or construct a diagonal.
->
->When the input is square, the diagonal elements are returned. If the input
->is vector-like, a diagonal matrix is constructed with it.
--}
-diag__0
- :: MX -> IO MX
-diag__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_diag__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "diag__1" c_diag__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Get the diagonal of a matrix or construct a diagonal When the input is
->square, the diagonal elements are returned. If the input is vector- like, a
->diagonal matrix is constructed with it.
--}
-diag__1
- :: SX -> IO SX
-diag__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_diag__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "diag__2" c_diag__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Get the diagonal of a matrix or construct a diagonal When the input is
->square, the diagonal elements are returned. If the input is vector- like, a
->diagonal matrix is constructed with it.
--}
-diag__2
- :: DMatrix -> IO DMatrix
-diag__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_diag__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "diag__3" c_diag__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Get the diagonal of a matrix or construct a diagonal When the input is
->square, the diagonal elements are returned. If the input is vector- like, a
->diagonal matrix is constructed with it.
--}
-diag__3
- :: IMatrix -> IO IMatrix
-diag__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_diag__3 errStrPtrP x0'
- 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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-dpleIn__3
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-dpleIn__4
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-dpleIn__5
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-dpleIn__6
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-dpleIn__7
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-dpleIn__8
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-dpleOut__2
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-dpleOut__3
- :: Vector MX -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-dpleOut__4
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-dpleOut__5
- :: Vector SX -> String -> IO (Vector SX)
-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 "eig_symbolic" c_eig_symbolic
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Attempts to find the eigenvalues of a symbolic matrix This will only work
->for up to 3x3 matrices.
->
->Bring m in block diagonal form, calculating eigenvalues of each block
->seperately
--}
-eig_symbolic
- :: 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')
-{-|
->Substitute variable v with value vdef in an expression ex, and evaluate
->numerically Note: this is not efficient. For critical parts (loops) of your
->code, always use SXFunction.
--}
-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')
-{-|
->Evaluate an SX graph numerically Note: this is not efficient. For critical
->parts (loops) of your code, always use SXFunction.
--}
-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 the expression as a weighted sum (with constant weights)
--}
-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 "explicitRK__0" c_explicitRK__0
- :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
-{-|
->Construct an explicit Runge-Kutta integrator.
->
->Parameters:
->-----------
->
->f: dynamical system
->
->>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
->
->+-----------+-------+----------------------------+
->| Full name | Short | Description |
->+===========+=======+============================+
->| DAE_X | x | Differential state . |
->+-----------+-------+----------------------------+
->| DAE_Z | z | Algebraic state . |
->+-----------+-------+----------------------------+
->| DAE_P | p | Parameter . |
->+-----------+-------+----------------------------+
->| DAE_T | t | Explicit time dependence . |
->+-----------+-------+----------------------------+
->
->>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
->
->+-----------+-------+--------------------------------------------+
->| Full name | Short | Description |
->+===========+=======+============================================+
->| DAE_ODE | ode | Right hand side of the implicit ODE . |
->+-----------+-------+--------------------------------------------+
->| DAE_ALG | alg | Right hand side of algebraic equations . |
->+-----------+-------+--------------------------------------------+
->| DAE_QUAD | quad | Right hand side of quadratures equations . |
->+-----------+-------+--------------------------------------------+
->
->Parameters:
->-----------
->
->tf: Integration end time
->
->order: Order of integration
->
->ne: Number of times the RK primitive is repeated over the integration
->interval
--}
-explicitRK__0
- :: Function -> IO Function
-explicitRK__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_explicitRK__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "explicitRK__1" c_explicitRK__1
- :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> IO (Ptr Function')
-{-|
->Construct an explicit Runge-Kutta integrator.
->
->Parameters:
->-----------
->
->f: dynamical system
->
->>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
->
->+-----------+-------+----------------------------+
->| Full name | Short | Description |
->+===========+=======+============================+
->| DAE_X | x | Differential state . |
->+-----------+-------+----------------------------+
->| DAE_Z | z | Algebraic state . |
->+-----------+-------+----------------------------+
->| DAE_P | p | Parameter . |
->+-----------+-------+----------------------------+
->| DAE_T | t | Explicit time dependence . |
->+-----------+-------+----------------------------+
->
->>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
->
->+-----------+-------+--------------------------------------------+
->| Full name | Short | Description |
->+===========+=======+============================================+
->| DAE_ODE | ode | Right hand side of the implicit ODE . |
->+-----------+-------+--------------------------------------------+
->| DAE_ALG | alg | Right hand side of algebraic equations . |
->+-----------+-------+--------------------------------------------+
->| DAE_QUAD | quad | Right hand side of quadratures equations . |
->+-----------+-------+--------------------------------------------+
->
->Parameters:
->-----------
->
->tf: Integration end time
->
->order: Order of integration
->
->ne: Number of times the RK primitive is repeated over the integration
->interval
--}
-explicitRK__1
- :: Function -> MX -> IO Function
-explicitRK__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_explicitRK__1 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "explicitRK__2" c_explicitRK__2
- :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> IO (Ptr Function')
-{-|
->Construct an explicit Runge-Kutta integrator.
->
->Parameters:
->-----------
->
->f: dynamical system
->
->>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
->
->+-----------+-------+----------------------------+
->| Full name | Short | Description |
->+===========+=======+============================+
->| DAE_X | x | Differential state . |
->+-----------+-------+----------------------------+
->| DAE_Z | z | Algebraic state . |
->+-----------+-------+----------------------------+
->| DAE_P | p | Parameter . |
->+-----------+-------+----------------------------+
->| DAE_T | t | Explicit time dependence . |
->+-----------+-------+----------------------------+
->
->>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
->
->+-----------+-------+--------------------------------------------+
->| Full name | Short | Description |
->+===========+=======+============================================+
->| DAE_ODE | ode | Right hand side of the implicit ODE . |
->+-----------+-------+--------------------------------------------+
->| DAE_ALG | alg | Right hand side of algebraic equations . |
->+-----------+-------+--------------------------------------------+
->| DAE_QUAD | quad | Right hand side of quadratures equations . |
->+-----------+-------+--------------------------------------------+
->
->Parameters:
->-----------
->
->tf: Integration end time
->
->order: Order of integration
->
->ne: Number of times the RK primitive is repeated over the integration
->interval
--}
-explicitRK__2
- :: Function -> MX -> Int -> IO Function
-explicitRK__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_explicitRK__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 "explicitRK__3" c_explicitRK__3
- :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> CInt -> IO (Ptr Function')
-{-|
->Construct an explicit Runge-Kutta integrator.
->
->Parameters:
->-----------
->
->f: dynamical system
->
->>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
->
->+-----------+-------+----------------------------+
->| Full name | Short | Description |
->+===========+=======+============================+
->| DAE_X | x | Differential state . |
->+-----------+-------+----------------------------+
->| DAE_Z | z | Algebraic state . |
->+-----------+-------+----------------------------+
->| DAE_P | p | Parameter . |
->+-----------+-------+----------------------------+
->| DAE_T | t | Explicit time dependence . |
->+-----------+-------+----------------------------+
->
->>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
->
->+-----------+-------+--------------------------------------------+
->| Full name | Short | Description |
->+===========+=======+============================================+
->| DAE_ODE | ode | Right hand side of the implicit ODE . |
->+-----------+-------+--------------------------------------------+
->| DAE_ALG | alg | Right hand side of algebraic equations . |
->+-----------+-------+--------------------------------------------+
->| DAE_QUAD | quad | Right hand side of quadratures equations . |
->+-----------+-------+--------------------------------------------+
->
->Parameters:
->-----------
->
->tf: Integration end time
->
->order: Order of integration
->
->ne: Number of times the RK primitive is repeated over the integration
->interval
--}
-explicitRK__3
- :: Function -> MX -> Int -> Int -> IO Function
-explicitRK__3 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_explicitRK__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 "extractShared__0" c_extractShared__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
-{-|
->Extract shared subexpressions from an set of expressions.
--}
-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 ()
-{-|
->Extract shared subexpressions from an set of expressions.
--}
-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 ()
-{-|
->Extract shared subexpressions from an set of expressions.
--}
-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 SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> IO ()
-{-|
->Extract shared subexpressions from an set of expressions.
--}
-extractShared__3
- :: Vector SXElement -> Vector SXElement -> Vector SXElement -> 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 SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr StdString -> IO ()
-{-|
->Extract shared subexpressions from an set of expressions.
--}
-extractShared__4
- :: Vector SXElement -> Vector SXElement -> Vector SXElement -> 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 SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr StdString -> Ptr StdString -> IO ()
-{-|
->Extract shared subexpressions from an set of expressions.
--}
-extractShared__5
- :: Vector SXElement -> Vector SXElement -> Vector SXElement -> 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')
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-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')
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-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')
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-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')
-{-|
->Get all the free variables in an expression.
--}
-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 "getMinor__0" c_getMinor__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SXElement')
-getMinor__0
- :: SX -> Int -> Int -> IO SXElement
-getMinor__0 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "getMinor__1" c_getMinor__1
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO CDouble
-getMinor__1
- :: DMatrix -> Int -> Int -> IO Double
-getMinor__1 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "getMinor__2" c_getMinor__2
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt
-getMinor__2
- :: IMatrix -> Int -> Int -> IO Int
-getMinor__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "getOperatorRepresentation__0" c_getOperatorRepresentation__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
-{-|
->Get a string representation for a binary MX, using custom arguments.
--}
-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 SXElement' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
-{-|
->Get a string representation for a binary SX, using custom arguments.
--}
-getOperatorRepresentation__1
- :: SXElement -> 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')))
-{-|
->Get all symbols contained in the supplied expression Get all symbols on
->which the supplied expression depends.
->
->See: MXFunction::getFree()
--}
-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')))
-{-|
->Get all symbols contained in the supplied expression Get all symbols on
->which the supplied expression depends.
->
->See: MXFunction::getFree()
--}
-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 (StdVec (Ptr SXElement')))
-{-|
->Get all symbols contained in the supplied expression Get all symbols on
->which the supplied expression depends.
->
->See: SXFunction::getFree()
--}
-getSymbols__2
- :: SX -> IO (Vector SXElement)
-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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-gradFIn__3
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-gradFIn__4
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-gradFIn__5
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-gradFIn__6
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-gradFIn__7
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-gradFIn__8
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-gradFOut__4
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-gradFOut__5
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-gradFOut__6
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-gradFOut__7
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-gradFOut__8
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-gradFOut__9
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-gradFOut__10
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-gradFOut__11
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 "gradient__0" c_gradient__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->split vertically, retaining groups of cols
->
->Parameters:
->-----------
->
->output_offset: List of all start cols for each group the last col group
->will run to the end.
->
->horzcat(horzsplit(x, ...)) = x
--}
-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')
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-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')))
-{-|
->Substitute variable var with expression expr in multiple expressions,
->preserving nodes.
--}
-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')
-{-|
->Substitute variable v with expression vdef in an expression ex, preserving
->nodes.
--}
-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 function.
->
->\\\\[ \\\\begin {cases} H(x) = 0 & x<0 \\\\\\\\ H(x) = 1/2 & x=0 \\\\\\\\
->H(x) = 1 & x>0 \\\\\\\\ \\\\end {cases} \\\\]
--}
-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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-hessLagIn__5
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagIn__6
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagIn__7
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagIn__8
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagIn__9
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-hessLagIn__10
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagIn__11
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagIn__12
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagIn__13
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagIn__14
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-hessLagOut__6
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagOut__7
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagOut__8
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagOut__9
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagOut__10
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hessLagOut__11
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-hessLagOut__12
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagOut__13
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagOut__14
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagOut__15
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagOut__16
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hessLagOut__17
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "hessian__0" c_hessian__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-hessian__0
- :: SX -> SX -> SX -> SX -> 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 SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-hessian__1
- :: SX -> SX -> IO SX
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-hnlpIn__4
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hnlpIn__5
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hnlpIn__6
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-hnlpIn__7
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-hnlpIn__8
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hnlpIn__9
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hnlpIn__10
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-hnlpIn__11
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 "horzcat__0" c_horzcat__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-{-|
->concatenate vertically
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzcat__0
- :: Vector MX -> IO MX
-horzcat__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzcat__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzcat__1" c_horzcat__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-{-|
->Concatenate a list of sparsities horizontally Alternative terminology:
->horizontal stack, hstack, horizontal append, [a b].
--}
-horzcat__1
- :: Vector Sparsity -> IO Sparsity
-horzcat__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzcat__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzcat__2" c_horzcat__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-{-|
->Concatenate a list of matrices vertically Alternative terminology: vertical
->stack, vstack, vertical append, [a;b].
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzcat__2
- :: Vector SX -> IO SX
-horzcat__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzcat__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzcat__3" c_horzcat__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-{-|
->Concatenate a list of matrices vertically Alternative terminology: vertical
->stack, vstack, vertical append, [a;b].
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzcat__3
- :: Vector DMatrix -> IO DMatrix
-horzcat__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzcat__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzcat__4" c_horzcat__4
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-{-|
->Concatenate a list of matrices vertically Alternative terminology: vertical
->stack, vstack, vertical append, [a;b].
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzcat__4
- :: Vector IMatrix -> IO IMatrix
-horzcat__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzcat__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__0" c_horzsplit__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__0
- :: MX -> IO (Vector MX)
-horzsplit__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__1" c_horzsplit__1
- :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__1
- :: MX -> Int -> IO (Vector MX)
-horzsplit__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "horzsplit__2" c_horzsplit__2
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
-{-|
->split vertically, retaining groups of cols
->
->Parameters:
->-----------
->
->output_offset: List of all start cols for each group the last col group
->will run to the end.
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__2
- :: MX -> Vector Int -> IO (Vector MX)
-horzsplit__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "horzsplit__3" c_horzsplit__3
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
-{-|
->Split up a sparsity pattern horizontally.
--}
-horzsplit__3
- :: Sparsity -> Vector Int -> IO (Vector Sparsity)
-horzsplit__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__3 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__4" c_horzsplit__4
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__4
- :: SX -> IO (Vector SX)
-horzsplit__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__5" c_horzsplit__5
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__5
- :: SX -> Int -> IO (Vector SX)
-horzsplit__5 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "horzsplit__6" c_horzsplit__6
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
-{-|
->split vertically, retaining groups of cols
->
->Parameters:
->-----------
->
->offset: List of all start cols for each group the last col group will run
->to the end.
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__6
- :: SX -> Vector Int -> IO (Vector SX)
-horzsplit__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__6 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__7" c_horzsplit__7
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__7
- :: DMatrix -> IO (Vector DMatrix)
-horzsplit__7 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__7 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__8" c_horzsplit__8
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__8
- :: DMatrix -> Int -> IO (Vector DMatrix)
-horzsplit__8 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "horzsplit__9" c_horzsplit__9
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
-{-|
->split vertically, retaining groups of cols
->
->Parameters:
->-----------
->
->offset: List of all start cols for each group the last col group will run
->to the end.
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__9
- :: DMatrix -> Vector Int -> IO (Vector DMatrix)
-horzsplit__9 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__9 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__10" c_horzsplit__10
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__10
- :: IMatrix -> IO (Vector IMatrix)
-horzsplit__10 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__10 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "horzsplit__11" c_horzsplit__11
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-{-|
->split vertically, retaining fixed-sized groups of cols
->
->Parameters:
->-----------
->
->incr: Size of each group of cols
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__11
- :: IMatrix -> Int -> IO (Vector IMatrix)
-horzsplit__11 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "horzsplit__12" c_horzsplit__12
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
-{-|
->split vertically, retaining groups of cols
->
->Parameters:
->-----------
->
->offset: List of all start cols for each group the last col group will run
->to the end.
->
->horzcat(horzsplit(x, ...)) = x
--}
-horzsplit__12
- :: IMatrix -> Vector Int -> IO (Vector IMatrix)
-horzsplit__12 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_horzsplit__12 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "if_else__0" c_if_else__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Branching on MX nodes Ternary operator, "cond ? if_true : if_false".
--}
-if_else__0
- :: MX -> MX -> MX -> IO MX
-if_else__0 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "if_else__1" c_if_else__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-if_else__1
- :: SX -> SX -> SX -> IO SX
-if_else__1 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_if_else__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 "implicitRK" c_implicitRK
- :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
-{-|
->Construct an implicit Runge-Kutta integrator.
->
->Parameters:
->-----------
->
->f: dynamical system
->
->>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
->
->+-----------+-------+----------------------------+
->| Full name | Short | Description |
->+===========+=======+============================+
->| DAE_X | x | Differential state . |
->+-----------+-------+----------------------------+
->| DAE_Z | z | Algebraic state . |
->+-----------+-------+----------------------------+
->| DAE_P | p | Parameter . |
->+-----------+-------+----------------------------+
->| DAE_T | t | Explicit time dependence . |
->+-----------+-------+----------------------------+
->
->>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
->
->+-----------+-------+--------------------------------------------+
->| Full name | Short | Description |
->+===========+=======+============================================+
->| DAE_ODE | ode | Right hand side of the implicit ODE . |
->+-----------+-------+--------------------------------------------+
->| DAE_ALG | alg | Right hand side of algebraic equations . |
->+-----------+-------+--------------------------------------------+
->| DAE_QUAD | quad | Right hand side of quadratures equations . |
->+-----------+-------+--------------------------------------------+
->
->Parameters:
->-----------
->
->tf: Integration end time
->
->order: Order of integration
->
->scheme: Collocation scheme, as excepted by collocationPoints function.
->
->ne: Number of times the RK primitive is repeated over the integration
->interval
--}
-implicitRK
- :: Function -> String -> IO Function
-implicitRK x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_implicitRK errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "inner_prod__0" c_inner_prod__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Take the inner product of two vectors Equals.
->
->with x and y vectors
--}
-inner_prod__0
- :: MX -> MX -> IO MX
-inner_prod__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "inner_prod__1" c_inner_prod__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Inner product of two matrices Equals.
->
->with x and y matrices of the same dimension
--}
-inner_prod__1
- :: SX -> SX -> IO SX
-inner_prod__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "inner_prod__2" c_inner_prod__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Inner product of two matrices Equals.
->
->with x and y matrices of the same dimension
--}
-inner_prod__2
- :: DMatrix -> DMatrix -> IO DMatrix
-inner_prod__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "inner_prod__3" c_inner_prod__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Inner product of two matrices Equals.
->
->with x and y matrices of the same dimension
--}
-inner_prod__3
- :: IMatrix -> IMatrix -> IO IMatrix
-inner_prod__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-integratorIn__7
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorIn__8
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorIn__9
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorIn__10
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorIn__11
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorIn__12
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorIn__13
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-integratorIn__14
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorIn__15
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorIn__16
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorIn__17
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorIn__18
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorIn__19
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorIn__20
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-integratorOut__7
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorOut__8
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorOut__9
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorOut__10
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorOut__11
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorOut__12
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-integratorOut__13
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-integratorOut__14
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorOut__15
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorOut__16
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorOut__17
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorOut__18
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorOut__19
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-integratorOut__20
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "inv__0" c_inv__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Matrix inverse (experimental)
--}
-inv__0
- :: MX -> IO MX
-inv__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_inv__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "inv__1" c_inv__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-inv__1
- :: SX -> IO SX
-inv__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_inv__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "inv__2" c_inv__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-inv__2
- :: DMatrix -> IO DMatrix
-inv__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_inv__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "inv__3" c_inv__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-inv__3
- :: IMatrix -> IO IMatrix
-inv__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_inv__3 errStrPtrP x0'
- 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
-{-|
->Check if the vector is strictly decreasing.
--}
-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
-{-|
->Check if the vector is strictly decreasing.
--}
-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 "isEqual__0" c_isEqual__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
-{-|
->Check if two expressions are equal, assuming that they are comparable.
--}
-isEqual__0
- :: MX -> MX -> IO Bool
-isEqual__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "isEqual__1" c_isEqual__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
-{-|
->Check if two expressions are equal, assuming that they are comparable.
--}
-isEqual__1
- :: SX -> SX -> IO Bool
-isEqual__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_isEqual__1 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "isEqual__2" c_isEqual__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt
-{-|
->Check if two expressions are equal, assuming that they are comparable.
--}
-isEqual__2
- :: DMatrix -> DMatrix -> IO Bool
-isEqual__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "isEqual__3" c_isEqual__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt
-{-|
->Check if two expressions are equal, assuming that they are comparable.
--}
-isEqual__3
- :: IMatrix -> IMatrix -> IO Bool
-isEqual__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_isEqual__3 errStrPtrP x0' x1'
- 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
-{-|
->Check if the vector is strictly increasing.
--}
-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
-{-|
->Check if the vector is strictly increasing.
--}
-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
-{-|
->Check if the vector is monotone.
--}
-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
-{-|
->Check if the vector is monotone.
--}
-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
-{-|
->Check if the vector is non-decreasing.
--}
-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
-{-|
->Check if the vector is non-decreasing.
--}
-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
-{-|
->Check if the vector is non-increasing.
--}
-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
-{-|
->Check if the vector is non-increasing.
--}
-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
-{-|
->Checks if vector does not contain NaN or Inf.
--}
-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
-{-|
->Checks if vector does not contain NaN or Inf.
--}
-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
-{-|
->Check if the vector is strictly monotone.
--}
-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
-{-|
->Check if the vector is strictly monotone.
--}
-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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-jacGIn__3
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-jacGIn__4
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-jacGIn__5
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-jacGIn__6
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-jacGIn__7
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-jacGIn__8
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-jacGOut__4
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-jacGOut__5
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-jacGOut__6
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-jacGOut__7
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-jacGOut__8
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-jacGOut__9
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-jacGOut__10
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-jacGOut__11
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 "jacobian__0" c_jacobian__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Calculate jacobian via source code transformation.
->
->Uses casadi::MXFunction::jac
--}
-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')
-{-|
->Calculate jacobian via source code transformation.
->
->Uses casadi::SXFunction::jac
--}
-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')
-{-|
->Calculate the Jacobian and multiply by a vector from the left This is
->equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
->transpose_jacobian set to false and true respectively. If contrast to these
->expressions, it will use directional derivatives which is typically (but not
->necessarily) more efficient if the complete Jacobian is not needed and v has
->few rows.
--}
-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')
-{-|
->Calculate the Jacobian and multiply by a vector from the left This is
->equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
->transpose_jacobian set to false and true respectively. If contrast to these
->expressions, it will use directional derivatives which is typically (but not
->necessarily) more efficient if the complete Jacobian is not needed and v has
->few rows.
--}
-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 "kron__0" c_kron__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Kronecker tensor product.
->
->Creates a block matrix in which each element (i, j) is a_ij*b
--}
-kron__0
- :: MX -> MX -> IO MX
-kron__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "kron__1" c_kron__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Kronecker tensor product.
->
->Creates a block matrix in which each element (i, j) is a_ij*b
--}
-kron__1
- :: SX -> SX -> IO SX
-kron__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "kron__2" c_kron__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Kronecker tensor product.
->
->Creates a block matrix in which each element (i, j) is a_ij*b
--}
-kron__2
- :: DMatrix -> DMatrix -> IO DMatrix
-kron__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "kron__3" c_kron__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Kronecker tensor product.
->
->Creates a block matrix in which each element (i, j) is a_ij*b
--}
-kron__3
- :: IMatrix -> IMatrix -> IO IMatrix
-kron__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-linsolIn__3
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-linsolIn__4
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-linsolIn__5
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-linsolIn__6
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-linsolIn__7
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-linsolIn__8
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-linsolOut__2
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-linsolOut__3
- :: Vector MX -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-linsolOut__4
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-linsolOut__5
- :: Vector SX -> String -> IO (Vector SX)
-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 "linspace__0" c_linspace__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
-{-|
->Matlab's linspace command.
--}
-linspace__0
- :: MX -> MX -> Int -> IO MX
-linspace__0 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "linspace__1" c_linspace__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
-{-|
->Matlab's linspace command.
--}
-linspace__1
- :: SX -> SX -> Int -> IO SX
-linspace__1 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "linspace__2" c_linspace__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
-{-|
->Matlab's linspace command.
--}
-linspace__2
- :: DMatrix -> DMatrix -> Int -> IO DMatrix
-linspace__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "logic_and__0" c_logic_and__0
- :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
-{-|
->Logical and, returns (an expression evaluating to) 1 if both expressions are
->nonzero and 0 otherwise.
--}
-logic_and__0
- :: SXElement -> SXElement -> IO SXElement
-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 MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Logical and, returns (an expression evaluating to) 1 if both expressions are
->nonzero and 0 otherwise.
--}
-logic_and__1
- :: MX -> MX -> IO MX
-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 SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Logical and, returns (an expression evaluating to) 1 if both expressions are
->nonzero and 0 otherwise.
--}
-logic_and__2
- :: SX -> SX -> IO SX
-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 DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Logical and, returns (an expression evaluating to) 1 if both expressions are
->nonzero and 0 otherwise.
--}
-logic_and__3
- :: DMatrix -> DMatrix -> IO DMatrix
-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) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Logical and, returns (an expression evaluating to) 1 if both expressions are
->nonzero and 0 otherwise.
--}
-logic_and__4
- :: IMatrix -> IMatrix -> IO IMatrix
-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) -> CDouble -> CDouble -> IO CDouble
-{-|
->Logical and, returns (an expression evaluating to) 1 if both expressions are
->nonzero and 0 otherwise.
--}
-logic_and__5
- :: Double -> Double -> IO Double
-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_and__6" c_logic_and__6
- :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt
-{-|
->Logical and, returns (an expression evaluating to) 1 if both expressions are
->nonzero and 0 otherwise.
--}
-logic_and__6
- :: Int -> Int -> IO Int
-logic_and__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_logic_and__6 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 SXElement' -> IO (Ptr SXElement')
-{-|
->Logical not, returns (an expression evaluating to) 1 if expression is zero
->and 0 otherwise.
--}
-logic_not__0
- :: SXElement -> IO SXElement
-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 MX' -> IO (Ptr MX')
-{-|
->Logical not, returns (an expression evaluating to) 1 if expression is zero
->and 0 otherwise.
--}
-logic_not__1
- :: MX -> IO MX
-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 SX' -> IO (Ptr SX')
-{-|
->Logical not, returns (an expression evaluating to) 1 if expression is zero
->and 0 otherwise.
--}
-logic_not__2
- :: SX -> IO SX
-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 DMatrix' -> IO (Ptr DMatrix')
-{-|
->Logical not, returns (an expression evaluating to) 1 if expression is zero
->and 0 otherwise.
--}
-logic_not__3
- :: DMatrix -> IO DMatrix
-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) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Logical not, returns (an expression evaluating to) 1 if expression is zero
->and 0 otherwise.
--}
-logic_not__4
- :: IMatrix -> IO IMatrix
-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) -> CDouble -> IO CDouble
-{-|
->Logical not, returns (an expression evaluating to) 1 if expression is zero
->and 0 otherwise.
--}
-logic_not__5
- :: Double -> IO Double
-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_not__6" c_logic_not__6
- :: Ptr (Ptr StdString) -> CInt -> IO CInt
-{-|
->Logical not, returns (an expression evaluating to) 1 if expression is zero
->and 0 otherwise.
--}
-logic_not__6
- :: Int -> IO Int
-logic_not__6 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_logic_not__6 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 SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
-{-|
->Logical or, returns (an expression evaluating to) 1 if at least one
->expression is nonzero and 0 otherwise.
--}
-logic_or__0
- :: SXElement -> SXElement -> IO SXElement
-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 MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Logical or, returns (an expression evaluating to) 1 if at least one
->expression is nonzero and 0 otherwise.
--}
-logic_or__1
- :: MX -> MX -> IO MX
-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 SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Logical or, returns (an expression evaluating to) 1 if at least one
->expression is nonzero and 0 otherwise.
--}
-logic_or__2
- :: SX -> SX -> IO SX
-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 DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Logical or, returns (an expression evaluating to) 1 if at least one
->expression is nonzero and 0 otherwise.
--}
-logic_or__3
- :: DMatrix -> DMatrix -> IO DMatrix
-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) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Logical or, returns (an expression evaluating to) 1 if at least one
->expression is nonzero and 0 otherwise.
--}
-logic_or__4
- :: IMatrix -> IMatrix -> IO IMatrix
-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) -> CDouble -> CDouble -> IO CDouble
-{-|
->Logical or, returns (an expression evaluating to) 1 if at least one
->expression is nonzero and 0 otherwise.
--}
-logic_or__5
- :: Double -> Double -> IO Double
-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 "logic_or__6" c_logic_or__6
- :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt
-{-|
->Logical or, returns (an expression evaluating to) 1 if at least one
->expression is nonzero and 0 otherwise.
--}
-logic_or__6
- :: Int -> Int -> IO Int
-logic_or__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_logic_or__6 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))
-{-|
->Returns a vector for quickly looking up entries of supplied list.
->
->lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v contains
->i
->
->Duplicates are treated by looking up last occurrence
--}
-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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-lpIn__7
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpIn__8
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpIn__9
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpIn__10
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpIn__11
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpIn__12
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpIn__13
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-lpIn__14
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpIn__15
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpIn__16
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpIn__17
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpIn__18
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpIn__19
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpIn__20
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-lpOut__5
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpOut__6
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpOut__7
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpOut__8
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-lpOut__9
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-lpOut__10
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpOut__11
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpOut__12
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpOut__13
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-lpOut__14
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 "matrix_expand__0" c_matrix_expand__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-{-|
->Expand MX graph to SXFunction call.
->
->Expand the given expression e, optionally supplying expressions contained in
->it at which expansion should stop.
--}
-matrix_expand__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')))
-{-|
->Expand MX graph to SXFunction call.
->
->Expand the given expression e, optionally supplying expressions contained in
->it at which expansion should stop.
--}
-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')
-{-|
->Expand MX graph to SXFunction call.
->
->Expand the given expression e, optionally supplying expressions contained in
->it at which expansion should stop.
--}
-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')
-{-|
->Expand MX graph to SXFunction call.
->
->Expand the given expression e, optionally supplying expressions contained in
->it at which expansion should stop.
--}
-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 "mayerIn__0" c_mayerIn__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity')))
-mayerIn__0
- :: Vector Sparsity -> IO (Vector Sparsity)
-mayerIn__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mayerIn__1" c_mayerIn__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-mayerIn__1
- :: Vector Sparsity -> String -> IO (Vector Sparsity)
-mayerIn__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__1 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mayerIn__2" c_mayerIn__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-mayerIn__2
- :: Vector Sparsity -> String -> String -> IO (Vector Sparsity)
-mayerIn__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__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 "mayerIn__3" c_mayerIn__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-mayerIn__3
- :: Vector MX -> IO (Vector MX)
-mayerIn__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mayerIn__4" c_mayerIn__4
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-mayerIn__4
- :: Vector MX -> String -> IO (Vector MX)
-mayerIn__4 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__4 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mayerIn__5" c_mayerIn__5
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-mayerIn__5
- :: Vector MX -> String -> String -> IO (Vector MX)
-mayerIn__5 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__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 "mayerIn__6" c_mayerIn__6
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
-mayerIn__6
- :: Vector SX -> IO (Vector SX)
-mayerIn__6 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__6 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mayerIn__7" c_mayerIn__7
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-mayerIn__7
- :: Vector SX -> String -> IO (Vector SX)
-mayerIn__7 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__7 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mayerIn__8" c_mayerIn__8
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-mayerIn__8
- :: Vector SX -> String -> String -> IO (Vector SX)
-mayerIn__8 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mayerIn__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 "mtaylor__0" c_mtaylor__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> CInt -> Ptr (StdVec CInt) -> IO (Ptr SX')
-{-|
->multivariate Taylor series expansion
->
->Do Taylor expansions until the aggregated order of a term is equal to
->'order'. The aggregated order of $x^n y^m$ equals $n+m$.
->
->The argument order_contributions can denote how match each variable
->contributes to the aggregated order. If x=[x, y] and order_contributions=[1,
->2], then the aggregated order of $x^n y^m$ equals $1n+2m$.
->
->Example usage
->
->$ \\\\sin(b+a)+\\\\cos(b+a)(x-a)+\\\\cos(b+a)(y-b) $ $ y+x-(x^3+3y x^2+3 y^2
->x+y^3)/6 $ $ (-3 x^2 y-x^3)/6+y+x $
--}
-mtaylor__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')
-{-|
->multivariate Taylor series expansion
->
->Do Taylor expansions until the aggregated order of a term is equal to
->'order'. The aggregated order of $x^n y^m$ equals $n+m$.
--}
-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')
-{-|
->multivariate Taylor series expansion
->
->Do Taylor expansions until the aggregated order of a term is equal to
->'order'. The aggregated order of $x^n y^m$ equals $n+m$.
--}
-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 "mul__0" c_mul__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-{-|
->Take the matrix product of n MX objects.
--}
-mul__0
- :: Vector MX -> IO MX
-mul__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mul__1" c_mul__1
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Take the matrix product of 2 MX objects.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient then.
--}
-mul__1
- :: MX -> MX -> IO MX
-mul__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "mul__2" c_mul__2
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
-{-|
->Take the matrix product of 2 MX objects.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient then.
--}
-mul__2
- :: MX -> MX -> Sparsity -> IO MX
-mul__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__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 "mul__3" c_mul__3
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
-{-|
->Get the sparsity resulting from a matrix multiplication.
--}
-mul__3
- :: Sparsity -> Sparsity -> IO Sparsity
-mul__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "mul__4" c_mul__4
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-{-|
->Matrix product of n matrices.
--}
-mul__4
- :: Vector SX -> IO SX
-mul__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mul__5" c_mul__5
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Matrix product of two matrices.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient in that case.
--}
-mul__5
- :: SX -> SX -> IO SX
-mul__5 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "mul__6" c_mul__6
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
-{-|
->Matrix product of two matrices.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient in that case.
--}
-mul__6
- :: SX -> SX -> Sparsity -> IO SX
-mul__6 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__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 "mul__7" c_mul__7
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-{-|
->Matrix product of n matrices.
--}
-mul__7
- :: Vector DMatrix -> IO DMatrix
-mul__7 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__7 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mul__8" c_mul__8
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Matrix product of two matrices.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient in that case.
--}
-mul__8
- :: DMatrix -> DMatrix -> IO DMatrix
-mul__8 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__8 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mul__9" c_mul__9
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
-{-|
->Matrix product of two matrices.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient in that case.
--}
-mul__9
- :: DMatrix -> DMatrix -> Sparsity -> IO DMatrix
-mul__9 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__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 "mul__10" c_mul__10
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-{-|
->Matrix product of n matrices.
--}
-mul__10
- :: Vector IMatrix -> IO IMatrix
-mul__10 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__10 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mul__11" c_mul__11
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Matrix product of two matrices.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient in that case.
--}
-mul__11
- :: IMatrix -> IMatrix -> IO IMatrix
-mul__11 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__11 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "mul__12" c_mul__12
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
-{-|
->Matrix product of two matrices.
->
->With optional sp_z you can specify the sparsity of the result A typical use
->case might be where the product is only constructed to inspect the trace of
->it. sp_z diagonal will be more efficient in that case.
--}
-mul__12
- :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix
-mul__12 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_mul__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__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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-nlpIn__3
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpIn__4
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpIn__5
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-nlpIn__6
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpIn__7
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpIn__8
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-nlpOut__3
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpOut__4
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpOut__5
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-nlpOut__6
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpOut__7
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpOut__8
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__9
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__10
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__11
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__12
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__13
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__14
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__15
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__16
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverIn__17
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__18
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__19
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__20
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__21
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__22
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__23
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__24
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__25
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverIn__26
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverOut__7
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverOut__8
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverOut__9
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverOut__10
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverOut__11
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverOut__12
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-nlpSolverOut__13
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverOut__14
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverOut__15
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverOut__16
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverOut__17
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverOut__18
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverOut__19
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-nlpSolverOut__20
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "norm_1__0" c_norm_1__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->1-norm
--}
-norm_1__0
- :: MX -> IO MX
-norm_1__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_1__1" c_norm_1__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->1-norm
--}
-norm_1__1
- :: SX -> IO SX
-norm_1__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_1__2" c_norm_1__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->1-norm
--}
-norm_1__2
- :: DMatrix -> IO DMatrix
-norm_1__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_1__3" c_norm_1__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->1-norm
--}
-norm_1__3
- :: IMatrix -> IO IMatrix
-norm_1__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_2__0" c_norm_2__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->2-norm
--}
-norm_2__0
- :: MX -> IO MX
-norm_2__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_2__1" c_norm_2__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->2-norm
--}
-norm_2__1
- :: SX -> IO SX
-norm_2__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_2__2" c_norm_2__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->2-norm
--}
-norm_2__2
- :: DMatrix -> IO DMatrix
-norm_2__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_2__3" c_norm_2__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->2-norm
--}
-norm_2__3
- :: IMatrix -> IO IMatrix
-norm_2__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_F__0" c_norm_F__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Frobenius norm.
--}
-norm_F__0
- :: MX -> IO MX
-norm_F__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_F__1" c_norm_F__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Frobenius norm.
--}
-norm_F__1
- :: SX -> IO SX
-norm_F__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_F__2" c_norm_F__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Frobenius norm.
--}
-norm_F__2
- :: DMatrix -> IO DMatrix
-norm_F__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_F__3" c_norm_F__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Frobenius norm.
--}
-norm_F__3
- :: IMatrix -> IO IMatrix
-norm_F__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_inf__0" c_norm_inf__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Infinity-norm.
--}
-norm_inf__0
- :: MX -> IO MX
-norm_inf__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_inf__1" c_norm_inf__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Infinity-norm.
--}
-norm_inf__1
- :: SX -> IO SX
-norm_inf__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_inf__2" c_norm_inf__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Infinity-norm.
--}
-norm_inf__2
- :: DMatrix -> IO DMatrix
-norm_inf__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "norm_inf__3" c_norm_inf__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Infinity-norm.
--}
-norm_inf__3
- :: IMatrix -> IO IMatrix
-norm_inf__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "nullspace__0" c_nullspace__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Computes the nullspace of a matrix A.
->
->Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
->
->Assumes A is full rank
->
->Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
--}
-nullspace__0
- :: MX -> IO MX
-nullspace__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_nullspace__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nullspace__1" c_nullspace__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Computes the nullspace of a matrix A.
->
->Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
->
->Assumes A is full rank
->
->Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
--}
-nullspace__1
- :: SX -> IO SX
-nullspace__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_nullspace__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nullspace__2" c_nullspace__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Computes the nullspace of a matrix A.
->
->Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
->
->Assumes A is full rank
->
->Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
--}
-nullspace__2
- :: DMatrix -> IO DMatrix
-nullspace__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_nullspace__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "nullspace__3" c_nullspace__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Computes the nullspace of a matrix A.
->
->Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
->
->Assumes A is full rank
->
->Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
--}
-nullspace__3
- :: IMatrix -> IO IMatrix
-nullspace__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_nullspace__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpIn__0" c_ocpIn__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpIn__0
- :: Vector Sparsity -> IO (Vector Sparsity)
-ocpIn__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpIn__1" c_ocpIn__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpIn__1
- :: Vector Sparsity -> String -> IO (Vector Sparsity)
-ocpIn__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__1 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpIn__2" c_ocpIn__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpIn__2
- :: Vector Sparsity -> String -> String -> IO (Vector Sparsity)
-ocpIn__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__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 "ocpIn__3" c_ocpIn__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpIn__3
- :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__3 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__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 "ocpIn__4" c_ocpIn__4
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpIn__4
- :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__5" c_ocpIn__5
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpIn__5
- :: Vector Sparsity -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__6" c_ocpIn__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')))
-ocpIn__6
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__7" c_ocpIn__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')))
-ocpIn__7
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__8" c_ocpIn__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')))
-ocpIn__8
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__9" c_ocpIn__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')))
-ocpIn__9
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__10" c_ocpIn__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')))
-ocpIn__10
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__11" c_ocpIn__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')))
-ocpIn__11
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__12" c_ocpIn__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')))
-ocpIn__12
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__13" c_ocpIn__13
- :: 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 -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpIn__13
- :: Vector Sparsity -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpIn__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_ocpIn__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 "ocpIn__14" c_ocpIn__14
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-ocpIn__14
- :: Vector MX -> IO (Vector MX)
-ocpIn__14 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__14 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpIn__15" c_ocpIn__15
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpIn__15
- :: Vector MX -> String -> IO (Vector MX)
-ocpIn__15 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__15 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpIn__16" c_ocpIn__16
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpIn__16
- :: Vector MX -> String -> String -> IO (Vector MX)
-ocpIn__16 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__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 "ocpIn__17" c_ocpIn__17
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpIn__17
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-ocpIn__17 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__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 "ocpIn__18" c_ocpIn__18
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpIn__18
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__19" c_ocpIn__19
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpIn__19
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__20" c_ocpIn__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')))
-ocpIn__20
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__21" c_ocpIn__21
- :: 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')))
-ocpIn__21
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__22" c_ocpIn__22
- :: 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')))
-ocpIn__22
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__23" c_ocpIn__23
- :: 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')))
-ocpIn__23
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__24" c_ocpIn__24
- :: 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')))
-ocpIn__24
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__25" c_ocpIn__25
- :: 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')))
-ocpIn__25
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__26" c_ocpIn__26
- :: 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')))
-ocpIn__26
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__27" c_ocpIn__27
- :: 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 -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpIn__27
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-ocpIn__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_ocpIn__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 "ocpIn__28" c_ocpIn__28
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__28
- :: Vector SX -> IO (Vector SX)
-ocpIn__28 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__28 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpIn__29" c_ocpIn__29
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__29
- :: Vector SX -> String -> IO (Vector SX)
-ocpIn__29 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__29 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpIn__30" c_ocpIn__30
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__30
- :: Vector SX -> String -> String -> IO (Vector SX)
-ocpIn__30 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__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 "ocpIn__31" c_ocpIn__31
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__31
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-ocpIn__31 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpIn__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 "ocpIn__32" c_ocpIn__32
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__32
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__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_ocpIn__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 "ocpIn__33" c_ocpIn__33
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__33
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__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_ocpIn__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 "ocpIn__34" c_ocpIn__34
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__34
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__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_ocpIn__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 "ocpIn__35" c_ocpIn__35
- :: 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')))
-ocpIn__35
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__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_ocpIn__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 "ocpIn__36" c_ocpIn__36
- :: 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')))
-ocpIn__36
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__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_ocpIn__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 "ocpIn__37" c_ocpIn__37
- :: 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')))
-ocpIn__37
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__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_ocpIn__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 "ocpIn__38" c_ocpIn__38
- :: 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')))
-ocpIn__38
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__38 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_ocpIn__38 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 "ocpIn__39" c_ocpIn__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 -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__39
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__39 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_ocpIn__39 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 "ocpIn__40" c_ocpIn__40
- :: 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')))
-ocpIn__40
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__40 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_ocpIn__40 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 "ocpIn__41" c_ocpIn__41
- :: 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 -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpIn__41
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-ocpIn__41 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_ocpIn__41 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 "ocpOut__0" c_ocpOut__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpOut__0
- :: Vector Sparsity -> IO (Vector Sparsity)
-ocpOut__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpOut__1" c_ocpOut__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpOut__1
- :: Vector Sparsity -> String -> IO (Vector Sparsity)
-ocpOut__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__1 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpOut__2" c_ocpOut__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpOut__2
- :: Vector Sparsity -> String -> String -> IO (Vector Sparsity)
-ocpOut__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__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 "ocpOut__3" c_ocpOut__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpOut__3
- :: Vector Sparsity -> String -> String -> String -> IO (Vector Sparsity)
-ocpOut__3 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__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 "ocpOut__4" c_ocpOut__4
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr Sparsity')))
-ocpOut__4
- :: Vector Sparsity -> String -> String -> String -> String -> IO (Vector Sparsity)
-ocpOut__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_ocpOut__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 "ocpOut__5" c_ocpOut__5
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
-ocpOut__5
- :: Vector MX -> IO (Vector MX)
-ocpOut__5 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__5 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpOut__6" c_ocpOut__6
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpOut__6
- :: Vector MX -> String -> IO (Vector MX)
-ocpOut__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__6 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpOut__7" c_ocpOut__7
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpOut__7
- :: Vector MX -> String -> String -> IO (Vector MX)
-ocpOut__7 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__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 "ocpOut__8" c_ocpOut__8
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpOut__8
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-ocpOut__8 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__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 "ocpOut__9" c_ocpOut__9
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-ocpOut__9
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-ocpOut__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_ocpOut__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 "ocpOut__10" c_ocpOut__10
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
-ocpOut__10
- :: Vector SX -> IO (Vector SX)
-ocpOut__10 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__10 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpOut__11" c_ocpOut__11
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpOut__11
- :: Vector SX -> String -> IO (Vector SX)
-ocpOut__11 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__11 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "ocpOut__12" c_ocpOut__12
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpOut__12
- :: Vector SX -> String -> String -> IO (Vector SX)
-ocpOut__12 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__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 "ocpOut__13" c_ocpOut__13
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpOut__13
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-ocpOut__13 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_ocpOut__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 "ocpOut__14" c_ocpOut__14
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-ocpOut__14
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-ocpOut__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_ocpOut__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 "outer_prod__0" c_outer_prod__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Take the outer product of two vectors Equals.
->
->with x and y vectors
--}
-outer_prod__0
- :: MX -> MX -> IO MX
-outer_prod__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "outer_prod__1" c_outer_prod__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Outer product of two vectors Equals.
->
->with x and y vectors
--}
-outer_prod__1
- :: SX -> SX -> IO SX
-outer_prod__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "outer_prod__2" c_outer_prod__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Outer product of two vectors Equals.
->
->with x and y vectors
--}
-outer_prod__2
- :: DMatrix -> DMatrix -> IO DMatrix
-outer_prod__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "outer_prod__3" c_outer_prod__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Outer product of two vectors Equals.
->
->with x and y vectors
--}
-outer_prod__3
- :: IMatrix -> IMatrix -> IO IMatrix
-outer_prod__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "pinv__0" c_pinv__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
-{-|
->Computes the Moore-Penrose pseudo-inverse.
->
->If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
->matrix A is slender (size2 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')
-{-|
->Computes the Moore-Penrose pseudo-inverse.
->
->If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
->matrix A is slender (size1 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')
-{-|
->Computes the Moore-Penrose pseudo-inverse.
->
->If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
->matrix A is slender (size1 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')
-{-|
->Computes the Moore-Penrose pseudo-inverse.
->
->If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
->matrix A is slender (size1 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')
-{-|
->Computes the Moore-Penrose pseudo-inverse.
->
->If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
->matrix A is slender (size2 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')
-{-|
->extracts polynomial coefficients from an expression
->
->ex Scalar expression that represents a polynomial x Scalar symbol that the
->polynomial is build up with
--}
-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')
-{-|
->Attempts to find the roots of a polynomial.
->
->This will only work for polynomials up to order 3 It is assumed that the
->roots are real.
--}
-poly_roots
- :: 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 "polyval__0" c_polyval__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Evaluate a polynomial with coefficients p in x.
--}
-polyval__0
- :: MX -> MX -> IO MX
-polyval__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "polyval__1" c_polyval__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Evaluate a polynomial with coefficients p in x.
--}
-polyval__1
- :: SX -> SX -> IO SX
-polyval__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "polyval__2" c_polyval__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Evaluate a polynomial with coefficients p in x.
--}
-polyval__2
- :: DMatrix -> DMatrix -> IO DMatrix
-polyval__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "polyval__3" c_polyval__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Evaluate a polynomial with coefficients p in x.
--}
-polyval__3
- :: IMatrix -> IMatrix -> IO IMatrix
-polyval__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "printCompact__0" c_printCompact__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
-{-|
->Print compact, introducing new variables for shared subexpressions.
--}
-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 ()
-{-|
->Print compact, introducing new variables for shared subexpressions.
--}
-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 "project__0" c_project__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
-{-|
->Create a new matrix with a given sparsity pattern but with the nonzeros
->taken from an existing matrix.
--}
-project__0
- :: SX -> Sparsity -> IO SX
-project__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "project__1" c_project__1
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
-{-|
->Create a new matrix with a given sparsity pattern but with the nonzeros
->taken from an existing matrix.
--}
-project__1
- :: DMatrix -> Sparsity -> IO DMatrix
-project__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_project__1 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "project__2" c_project__2
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
-{-|
->Create a new matrix with a given sparsity pattern but with the nonzeros
->taken from an existing matrix.
--}
-project__2
- :: IMatrix -> Sparsity -> IO IMatrix
-project__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "pw_const" c_pw_const
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Create a piecewise constant function Create a piecewise constant function
->with n=val.size() intervals.
->
->Inputs:
->
->Parameters:
->-----------
->
->t: a scalar variable (e.g. time)
->
->tval: vector with the discrete values of t at the interval transitions
->(length n-1)
->
->val: vector with the value of the function for each interval (length n)
--}
-pw_const
- :: 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 SXElement' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->t a scalar variable (e.g. time)
->
->Create a piecewise linear function Create a piecewise linear function:
->
->Inputs: tval vector with the the discrete values of t (monotonically
->increasing) val vector with the corresponding function values (same length
->as tval)
--}
-pw_lin
- :: SXElement -> 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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__13
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__14
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__15
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__16
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__17
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__18
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__19
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__20
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpIn__21
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__22
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__23
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__24
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__25
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__26
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__27
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__28
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__29
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__30
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__31
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__32
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__33
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpIn__34
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__35
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__36
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__37
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__38
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-qcqpOut__5
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpOut__6
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpOut__7
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpOut__8
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qcqpOut__9
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-qcqpOut__10
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpOut__11
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpOut__12
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpOut__13
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qcqpOut__14
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__10
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__11
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__12
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__13
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__14
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__15
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__16
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__17
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpIn__18
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__19
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__20
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__21
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__22
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__23
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__24
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__25
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__26
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__27
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpIn__28
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__29
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-qpOut__5
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpOut__6
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpOut__7
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpOut__8
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-qpOut__9
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-qpOut__10
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpOut__11
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpOut__12
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpOut__13
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-qpOut__14
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 function
->
->\\\\[ \\\\begin {cases} R(x) = 0 & x <= 1 \\\\\\\\ R(x) = x & x > 1 \\\\\\\\
->\\\\end {cases} \\\\]
->
->Also called: slope function
--}
-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 "rank" c_rank
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
-{-|
->Obtain the structural rank of a sparsity-pattern.
--}
-rank
- :: Sparsity -> IO Int
-rank x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_rank 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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__8
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__9
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__10
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__11
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__12
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__13
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__14
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeIn__15
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__16
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__17
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__18
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__19
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__20
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__21
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__22
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeIn__23
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-rdaeOut__4
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeOut__5
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeOut__6
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-rdaeOut__7
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-rdaeOut__8
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeOut__9
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeOut__10
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-rdaeOut__11
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 "rectangle" c_rectangle
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->rectangle function
->
->\\\\[ \\\\begin {cases} \\\\Pi(x) = 1 & |x| < 1/2 \\\\\\\\ \\\\Pi(x) = 1/2 &
->|x| = 1/2 \\\\\\\\ \\\\Pi(x) = 0 & |x| > 1/2 \\\\\\\\ \\\\end {cases} \\\\]
->
->Also called: gate function, block function, band function, pulse function,
->window function
--}
-rectangle
- :: 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 "repmat__0" c_repmat__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
-{-|
->Repeat matrix A n times vertically and m times horizontally.
--}
-repmat__0
- :: MX -> Int -> Int -> IO MX
-repmat__0 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_repmat__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 "repmat__1" c_repmat__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-{-|
->Repeat matrix A n times vertically and m times horizontally.
--}
-repmat__1
- :: SX -> Int -> Int -> IO SX
-repmat__1 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_repmat__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 "repmat__2" c_repmat__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-{-|
->Repeat matrix A n times vertically and m times horizontally.
--}
-repmat__2
- :: DMatrix -> Int -> Int -> IO DMatrix
-repmat__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "repmat__3" c_repmat__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-{-|
->Repeat matrix A n times vertically and m times horizontally.
--}
-repmat__3
- :: IMatrix -> Int -> Int -> IO IMatrix
-repmat__3 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_repmat__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 "reshape__0" c_reshape__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
-{-|
->Reshape the MX.
--}
-reshape__0
- :: MX -> Sparsity -> IO MX
-reshape__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "reshape__1" c_reshape__1
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
-{-|
->Reshape the sparsity pattern keeping the relative location of the nonzeros.
--}
-reshape__1
- :: Sparsity -> Int -> Int -> IO Sparsity
-reshape__1 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_reshape__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 "reshape__2" c_reshape__2
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
-reshape__2
- :: SX -> Sparsity -> IO SX
-reshape__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_reshape__2 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "reshape__3" c_reshape__3
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
-reshape__3
- :: SX -> Int -> Int -> IO SX
-reshape__3 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_reshape__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 "reshape__4" c_reshape__4
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
-reshape__4
- :: DMatrix -> Sparsity -> IO DMatrix
-reshape__4 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "reshape__5" c_reshape__5
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
-reshape__5
- :: DMatrix -> Int -> Int -> IO DMatrix
-reshape__5 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "reshape__6" c_reshape__6
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
-reshape__6
- :: IMatrix -> Sparsity -> IO IMatrix
-reshape__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "reshape__7" c_reshape__7
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
-reshape__7
- :: IMatrix -> Int -> Int -> IO IMatrix
-reshape__7 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_reshape__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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__9
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__10
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__11
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__12
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__13
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__14
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__15
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__16
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpIn__17
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__18
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__19
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__20
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__21
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__22
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__23
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__24
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__25
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpIn__26
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__8
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__9
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__10
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__11
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__12
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__13
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__14
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdpOut__15
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__16
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__17
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__18
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__19
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__20
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__21
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__22
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdpOut__23
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__10
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__11
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__12
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__13
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__14
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__15
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__16
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__17
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpIn__18
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__19
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__20
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__21
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__22
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__23
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__24
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__25
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__26
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__27
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpIn__28
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__29
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__8
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__9
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__10
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__11
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__12
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__13
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__14
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-sdqpOut__15
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__16
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__17
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__18
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__19
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__20
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__21
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__22
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-sdqpOut__23
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 "simplify__0" c_simplify__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
-{-|
->Simplify an expression.
--}
-simplify__0
- :: MX -> IO ()
-simplify__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_simplify__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "simplify__1" c_simplify__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
-{-|
->Simplify an expression.
--}
-simplify__1
- :: SX -> IO ()
-simplify__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_simplify__1 errStrPtrP x0'
- 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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__11
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__12
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__13
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__14
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__15
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__16
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__17
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__18
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpIn__19
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__20
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__21
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__22
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__23
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__24
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__25
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__26
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__27
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__28
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__29
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpIn__30
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__31
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__32
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-socpOut__5
- :: Vector MX -> IO (Vector MX)
-socpOut__5 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_socpOut__5 errStrPtrP x0'
- 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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpOut__6
- :: Vector MX -> String -> IO (Vector MX)
-socpOut__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_socpOut__6 errStrPtrP x0' x1'
- 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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpOut__7
- :: Vector MX -> String -> String -> IO (Vector MX)
-socpOut__7 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_socpOut__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 "socpOut__8" c_socpOut__8
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpOut__8
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-socpOut__8 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_socpOut__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 "socpOut__9" c_socpOut__9
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-socpOut__9
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-socpOut__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_socpOut__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 "socpOut__10" c_socpOut__10
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
-socpOut__10
- :: Vector SX -> IO (Vector SX)
-socpOut__10 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_socpOut__10 errStrPtrP x0'
- 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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpOut__11
- :: Vector SX -> String -> IO (Vector SX)
-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 (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpOut__12
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpOut__13
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-socpOut__14
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 "solve__0" c_solve__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Solve a system of equations: A*x = b.
--}
-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 a system of equations: A*x = b.
--}
-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 a system of equations: A*x = b The solve routine works similar to
->Matlab's backslash when A is square and nonsingular. The algorithm used is
->the following:
->
->A simple forward or backward substitution if A is upper or lower triangular
->
->If the linear system is at most 3-by-3, form the inverse via minor expansion
->and multiply
->
->Permute the variables and equations as to get a (structurally) nonzero
->diagonal, then perform a QR factorization without pivoting and solve the
->factorized system.
->
->Note 1: If there are entries of the linear system known to be zero, these
->will be removed. Elements that are very small, or will evaluate to be zero,
->can still cause numerical errors, due to the lack of pivoting (which is not
->possible since cannot compare the size of entries)
->
->Note 2: When permuting the linear system, a BLT (block lower triangular)
->transformation is formed. Only the permutation part of this is however used.
->An improvement would be to solve block-by-block if there are multiple BLT
->blocks.
--}
-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 a system of equations: A*x = b The solve routine works similar to
->Matlab's backslash when A is square and nonsingular. The algorithm used is
->the following:
->
->A simple forward or backward substitution if A is upper or lower triangular
->
->If the linear system is at most 3-by-3, form the inverse via minor expansion
->and multiply
->
->Permute the variables and equations as to get a (structurally) nonzero
->diagonal, then perform a QR factorization without pivoting and solve the
->factorized system.
->
->Note 1: If there are entries of the linear system known to be zero, these
->will be removed. Elements that are very small, or will evaluate to be zero,
->can still cause numerical errors, due to the lack of pivoting (which is not
->possible since cannot compare the size of entries)
->
->Note 2: When permuting the linear system, a BLT (block lower triangular)
->transformation is formed. Only the permutation part of this is however used.
->An improvement would be to solve block-by-block if there are multiple BLT
->blocks.
--}
-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 a system of equations: A*x = b The solve routine works similar to
->Matlab's backslash when A is square and nonsingular. The algorithm used is
->the following:
->
->A simple forward or backward substitution if A is upper or lower triangular
->
->If the linear system is at most 3-by-3, form the inverse via minor expansion
->and multiply
->
->Permute the variables and equations as to get a (structurally) nonzero
->diagonal, then perform a QR factorization without pivoting and solve the
->factorized system.
->
->Note 1: If there are entries of the linear system known to be zero, these
->will be removed. Elements that are very small, or will evaluate to be zero,
->can still cause numerical errors, due to the lack of pivoting (which is not
->possible since cannot compare the size of entries)
->
->Note 2: When permuting the linear system, a BLT (block lower triangular)
->transformation is formed. Only the permutation part of this is however used.
->An improvement would be to solve block-by-block if there are multiple BLT
->blocks.
--}
-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 a system of equations: A*x = b.
--}
-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 "sparse__0" c_sparse__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Make a matrix sparse by removing numerical zeros.
--}
-sparse__0
- :: SX -> IO SX
-sparse__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sparse__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sparse__1" c_sparse__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO (Ptr SX')
-{-|
->Make a matrix sparse by removing numerical zeros.
--}
-sparse__1
- :: SX -> Double -> IO SX
-sparse__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sparse__1 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sparse__2" c_sparse__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Make a matrix sparse by removing numerical zeros.
--}
-sparse__2
- :: DMatrix -> IO DMatrix
-sparse__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sparse__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sparse__3" c_sparse__3
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO (Ptr DMatrix')
-{-|
->Make a matrix sparse by removing numerical zeros.
--}
-sparse__3
- :: DMatrix -> Double -> IO DMatrix
-sparse__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sparse__3 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sparse__4" c_sparse__4
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Make a matrix sparse by removing numerical zeros.
--}
-sparse__4
- :: IMatrix -> IO IMatrix
-sparse__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sparse__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sparse__5" c_sparse__5
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO (Ptr IMatrix')
-{-|
->Make a matrix sparse by removing numerical zeros.
--}
-sparse__5
- :: IMatrix -> Double -> IO IMatrix
-sparse__5 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sparse__5 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sprank__0" c_sprank__0
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
-{-|
->Obtain the structural rank of a sparsity-pattern.
--}
-sprank__0
- :: SX -> IO Int
-sprank__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sprank__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sprank__1" c_sprank__1
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
-{-|
->Obtain the structural rank of a sparsity-pattern.
--}
-sprank__1
- :: DMatrix -> IO Int
-sprank__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sprank__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sprank__2" c_sprank__2
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-{-|
->Obtain the structural rank of a sparsity-pattern.
--}
-sprank__2
- :: IMatrix -> IO Int
-sprank__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sprank__2 errStrPtrP x0'
- 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')
-{-|
->Get the sparsity pattern of a matrix.
--}
-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 MX')) -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__13
- :: Vector MX -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__14
- :: Vector MX -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__15
- :: Vector MX -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__16
- :: Vector MX -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__17
- :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__18
- :: Vector MX -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__19
- :: Vector MX -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__20
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
-stabilizedQpIn__21
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__22
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__23
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__24
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 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__25
- :: Vector MX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector MX)
-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 SX')) -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__26
- :: Vector SX -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__27
- :: Vector SX -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__28
- :: Vector SX -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__29
- :: Vector SX -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__30
- :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__31
- :: Vector SX -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__32
- :: Vector SX -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__33
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
-stabilizedQpIn__34
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__35
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__36
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__37
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 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__38
- :: Vector SX -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> String -> IO (Vector SX)
-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 "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 variable var with expression expr in multiple expressions.
--}
-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 variable v with expression vdef in an expression ex.
--}
-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 variable var with expression expr in multiple expressions.
--}
-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 variable v with expression vdef in an expression ex.
--}
-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 SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
-{-|
->Substitute variable var out of or into an expression expr, with an arbitrary
->number of other expressions piggyback (vector version)
--}
-substituteInPlace__0
- :: Vector SX -> Vector SX -> Vector SX -> 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 SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
-{-|
->Substitute variable var out of or into an expression expr, with an arbitrary
->number of other expressions piggyback (vector version)
--}
-substituteInPlace__1
- :: Vector SX -> Vector SX -> Vector SX -> 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 SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> IO ()
-{-|
->Substitute variable var out of or into an expression expr, with an arbitrary
->number of other expressions piggyback.
--}
-substituteInPlace__2
- :: SX -> SX -> Vector SX -> IO ()
-substituteInPlace__2 x0 x1 x2 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "substituteInPlace__3" c_substituteInPlace__3
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
-{-|
->Substitute variable var out of or into an expression expr, with an arbitrary
->number of other expressions piggyback.
--}
-substituteInPlace__3
- :: SX -> SX -> Vector SX -> Bool -> IO ()
-substituteInPlace__3 x0 x1 x2 x3 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- withMarshal x2 $ \x2' ->
- withMarshal x3 $ \x3' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "substituteInPlace__4" c_substituteInPlace__4
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO ()
-{-|
->Substitute variable var out of or into an expression expr.
--}
-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 ()
-{-|
->Substitute variable var out of or into an expression expr.
--}
-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 "sumAll__0" c_sumAll__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Return summation of all elements.
--}
-sumAll__0
- :: MX -> IO MX
-sumAll__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumAll__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumAll__1" c_sumAll__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Return summation of all elements.
--}
-sumAll__1
- :: SX -> IO SX
-sumAll__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumAll__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumAll__2" c_sumAll__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Return summation of all elements.
--}
-sumAll__2
- :: DMatrix -> IO DMatrix
-sumAll__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumAll__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumAll__3" c_sumAll__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Return summation of all elements.
--}
-sumAll__3
- :: IMatrix -> IO IMatrix
-sumAll__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumAll__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumCols__0" c_sumCols__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Return a col-wise summation of elements.
--}
-sumCols__0
- :: MX -> IO MX
-sumCols__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumCols__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumCols__1" c_sumCols__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Return a col-wise summation of elements.
--}
-sumCols__1
- :: SX -> IO SX
-sumCols__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumCols__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumCols__2" c_sumCols__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Return a col-wise summation of elements.
--}
-sumCols__2
- :: DMatrix -> IO DMatrix
-sumCols__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumCols__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumCols__3" c_sumCols__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Return a col-wise summation of elements.
--}
-sumCols__3
- :: IMatrix -> IO IMatrix
-sumCols__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumCols__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumRows__0" c_sumRows__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Return a row-wise summation of elements.
--}
-sumRows__0
- :: MX -> IO MX
-sumRows__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumRows__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumRows__1" c_sumRows__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Return a row-wise summation of elements.
--}
-sumRows__1
- :: SX -> IO SX
-sumRows__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumRows__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumRows__2" c_sumRows__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Return a row-wise summation of elements.
--}
-sumRows__2
- :: DMatrix -> IO DMatrix
-sumRows__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumRows__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "sumRows__3" c_sumRows__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Return a row-wise summation of elements.
--}
-sumRows__3
- :: IMatrix -> IO IMatrix
-sumRows__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_sumRows__3 errStrPtrP x0'
- 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')
-{-|
->split vertically, retaining groups of cols
->
->Parameters:
->-----------
->
->output_offset: List of all start cols for each group the last col group
->will run to the end.
->
->horzcat(horzsplit(x, ...)) = x
--}
-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')
-{-|
->Integrate f from a to b using Gaussian quadrature with n points.
--}
-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')
-{-|
->univariate Taylor series expansion
->
->Calculate the Taylor expansion of expression 'ex' up to order 'order' with
->respect to variable 'x' around the point 'a'
->
->$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
->{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
->
->Example usage:
->
->::
->
->>> x
--}
-taylor__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')
-{-|
->univariate Taylor series expansion
->
->Calculate the Taylor expansion of expression 'ex' up to order 'order' with
->respect to variable 'x' around the point 'a'
->
->$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
->{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
->
->Example usage:
->
->::
->
->>> x
--}
-taylor__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')
-{-|
->univariate Taylor series expansion
->
->Calculate the Taylor expansion of expression 'ex' up to order 'order' with
->respect to variable 'x' around the point 'a'
->
->$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
->{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
->
->Example usage:
->
->::
->
->>> x
--}
-taylor__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 "trace__0" c_trace__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Matrix trace.
--}
-trace__0
- :: MX -> IO MX
-trace__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_trace__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "trace__1" c_trace__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SXElement')
-trace__1
- :: SX -> IO SXElement
-trace__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_trace__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "trace__2" c_trace__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CDouble
-trace__2
- :: DMatrix -> IO Double
-trace__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_trace__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "trace__3" c_trace__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
-trace__3
- :: IMatrix -> IO Int
-trace__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_trace__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "transpose__0" c_transpose__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Transpose an expression.
--}
-transpose__0
- :: MX -> IO MX
-transpose__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_transpose__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "transpose__1" c_transpose__1
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-{-|
->Transpose the pattern.
--}
-transpose__1
- :: Sparsity -> IO Sparsity
-transpose__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_transpose__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "transpose__2" c_transpose__2
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Transpose of a matrix.
--}
-transpose__2
- :: SX -> IO SX
-transpose__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_transpose__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "transpose__3" c_transpose__3
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Transpose of a matrix.
--}
-transpose__3
- :: DMatrix -> IO DMatrix
-transpose__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_transpose__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "transpose__4" c_transpose__4
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Transpose of a matrix.
--}
-transpose__4
- :: IMatrix -> IO IMatrix
-transpose__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_transpose__4 errStrPtrP x0'
- 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 function
->
->\\\\[ \\\\begin {cases} \\\\Lambda(x) = 0 & |x| >= 1 \\\\\\\\ \\\\Lambda(x)
->= 1-|x| & |x| < 1 \\\\end {cases} \\\\]
--}
-triangle
- :: SX -> IO SX
-triangle x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triangle errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril__0" c_tril__0
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-{-|
->Get lower triangular part.
--}
-tril__0
- :: Sparsity -> IO Sparsity
-tril__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril__1" c_tril__1
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-{-|
->Get lower triangular part.
--}
-tril__1
- :: Sparsity -> Bool -> IO Sparsity
-tril__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "tril__2" c_tril__2
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Get the lower triangular part of a matrix.
--}
-tril__2
- :: MX -> IO MX
-tril__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril__3" c_tril__3
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Get the lower triangular part of a matrix.
--}
-tril__3
- :: SX -> IO SX
-tril__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril__4" c_tril__4
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Get the lower triangular part of a matrix.
--}
-tril__4
- :: DMatrix -> IO DMatrix
-tril__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril__5" c_tril__5
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Get the lower triangular part of a matrix.
--}
-tril__5
- :: IMatrix -> IO IMatrix
-tril__5 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril__5 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril2symm__0" c_tril2symm__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Convert a lower triangular matrix to a symmetric one.
--}
-tril2symm__0
- :: MX -> IO MX
-tril2symm__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril2symm__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril2symm__1" c_tril2symm__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Convert a lower triangular matrix to a symmetric one.
--}
-tril2symm__1
- :: SX -> IO SX
-tril2symm__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril2symm__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril2symm__2" c_tril2symm__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Convert a lower triangular matrix to a symmetric one.
--}
-tril2symm__2
- :: DMatrix -> IO DMatrix
-tril2symm__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril2symm__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "tril2symm__3" c_tril2symm__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Convert a lower triangular matrix to a symmetric one.
--}
-tril2symm__3
- :: IMatrix -> IO IMatrix
-tril2symm__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_tril2symm__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu__0" c_triu__0
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-{-|
->Get upper triangular part.
--}
-triu__0
- :: Sparsity -> IO Sparsity
-triu__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu__1" c_triu__1
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
-{-|
->Get upper triangular part.
--}
-triu__1
- :: Sparsity -> Bool -> IO Sparsity
-triu__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "triu__2" c_triu__2
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Get the upper triangular part of a matrix.
--}
-triu__2
- :: MX -> IO MX
-triu__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu__3" c_triu__3
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Get the upper triangular part of a matrix.
--}
-triu__3
- :: SX -> IO SX
-triu__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu__4" c_triu__4
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Get the upper triangular part of a matrix.
--}
-triu__4
- :: DMatrix -> IO DMatrix
-triu__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu__5" c_triu__5
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Get the upper triangular part of a matrix.
--}
-triu__5
- :: IMatrix -> IO IMatrix
-triu__5 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu__5 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu2symm__0" c_triu2symm__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Convert a upper triangular matrix to a symmetric one.
--}
-triu2symm__0
- :: MX -> IO MX
-triu2symm__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu2symm__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu2symm__1" c_triu2symm__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Convert a upper triangular matrix to a symmetric one.
--}
-triu2symm__1
- :: SX -> IO SX
-triu2symm__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu2symm__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu2symm__2" c_triu2symm__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Convert a upper triangular matrix to a symmetric one.
--}
-triu2symm__2
- :: DMatrix -> IO DMatrix
-triu2symm__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu2symm__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "triu2symm__3" c_triu2symm__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Convert a upper triangular matrix to a symmetric one.
--}
-triu2symm__3
- :: IMatrix -> IO IMatrix
-triu2symm__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_triu2symm__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "unite__0" c_unite__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
-{-|
->Unite two matrices no overlapping sparsity.
--}
-unite__0
- :: MX -> MX -> IO MX
-unite__0 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "unite__1" c_unite__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
-{-|
->Unite two matrices no overlapping sparsity.
--}
-unite__1
- :: SX -> SX -> IO SX
-unite__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "unite__2" c_unite__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Unite two matrices no overlapping sparsity.
--}
-unite__2
- :: DMatrix -> DMatrix -> IO DMatrix
-unite__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "unite__3" c_unite__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Unite two matrices no overlapping sparsity.
--}
-unite__3
- :: IMatrix -> IMatrix -> IO IMatrix
-unite__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "vec__0" c_vec__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Returns a vectorized version of the MX Same as reshape(x, x.numel(), 1)
->
->a c b d
->
->turns into
->
->a b c d
--}
-vec__0
- :: MX -> IO MX
-vec__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vec__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vec__1" c_vec__1
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
-{-|
->Vectorize the pattern.
--}
-vec__1
- :: Sparsity -> IO Sparsity
-vec__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vec__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vec__2" c_vec__2
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->make a vector Reshapes/vectorizes the Matrix such that the shape
->becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
->reshape(expr, expr.numel(), 1)
->
->a c b d turns into
->
->a b c d
--}
-vec__2
- :: SX -> IO SX
-vec__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vec__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vec__3" c_vec__3
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->make a vector Reshapes/vectorizes the Matrix such that the shape
->becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
->reshape(expr, expr.numel(), 1)
->
->a c b d turns into
->
->a b c d
--}
-vec__3
- :: DMatrix -> IO DMatrix
-vec__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vec__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vec__4" c_vec__4
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->make a vector Reshapes/vectorizes the Matrix such that the shape
->becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
->reshape(expr, expr.numel(), 1)
->
->a c b d turns into
->
->a b c d
--}
-vec__4
- :: IMatrix -> IO IMatrix
-vec__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vec__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZ__0" c_vecNZ__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
-{-|
->Returns a vectorized version of the MX, preserving only nonzeros.
--}
-vecNZ__0
- :: MX -> IO MX
-vecNZ__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZ__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZ__1" c_vecNZ__1
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
-{-|
->Returns a flattened version of the Matrix, preserving only nonzeros.
--}
-vecNZ__1
- :: SX -> IO SX
-vecNZ__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZ__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZ__2" c_vecNZ__2
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
-{-|
->Returns a flattened version of the Matrix, preserving only nonzeros.
--}
-vecNZ__2
- :: DMatrix -> IO DMatrix
-vecNZ__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZ__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZ__3" c_vecNZ__3
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
-{-|
->Returns a flattened version of the Matrix, preserving only nonzeros.
--}
-vecNZ__3
- :: IMatrix -> IO IMatrix
-vecNZ__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZ__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZcat__0" c_vecNZcat__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-{-|
->concatenate vertically while vecing all arguments with vecNZ
--}
-vecNZcat__0
- :: Vector MX -> IO MX
-vecNZcat__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZcat__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZcat__1" c_vecNZcat__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-{-|
->concatenate vertically while vectorizing all arguments with vecNZ
--}
-vecNZcat__1
- :: Vector SX -> IO SX
-vecNZcat__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZcat__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZcat__2" c_vecNZcat__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-{-|
->concatenate vertically while vectorizing all arguments with vecNZ
--}
-vecNZcat__2
- :: Vector DMatrix -> IO DMatrix
-vecNZcat__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZcat__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vecNZcat__3" c_vecNZcat__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-{-|
->concatenate vertically while vectorizing all arguments with vecNZ
--}
-vecNZcat__3
- :: Vector IMatrix -> IO IMatrix
-vecNZcat__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vecNZcat__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "veccat__0" c_veccat__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-{-|
->Concatenate vertically while vectorizing all arguments.
--}
-veccat__0
- :: Vector MX -> IO MX
-veccat__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_veccat__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "veccat__1" c_veccat__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-{-|
->concatenate vertically while vectorizing all arguments with vec
--}
-veccat__1
- :: Vector SX -> IO SX
-veccat__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_veccat__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "veccat__2" c_veccat__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-{-|
->concatenate vertically while vectorizing all arguments with vec
--}
-veccat__2
- :: Vector DMatrix -> IO DMatrix
-veccat__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_veccat__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "veccat__3" c_veccat__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-{-|
->concatenate vertically while vectorizing all arguments with vec
--}
-veccat__3
- :: Vector IMatrix -> IO IMatrix
-veccat__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_veccat__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertcat__0" c_vertcat__0
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
-{-|
->concatenate horizontally
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertcat__0
- :: Vector MX -> IO MX
-vertcat__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertcat__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertcat__1" c_vertcat__1
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
-{-|
->Concatenate a list of sparsities vertically Alternative terminology:
->vertical stack, vstack, vertical append, [a;b].
--}
-vertcat__1
- :: Vector Sparsity -> IO Sparsity
-vertcat__1 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertcat__1 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertcat__2" c_vertcat__2
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
-{-|
->Concatenate a list of matrices horizontally Alternative terminology:
->horizontal stack, hstack, horizontal append, [a b].
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertcat__2
- :: Vector SX -> IO SX
-vertcat__2 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertcat__2 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertcat__3" c_vertcat__3
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
-{-|
->Concatenate a list of matrices horizontally Alternative terminology:
->horizontal stack, hstack, horizontal append, [a b].
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertcat__3
- :: Vector DMatrix -> IO DMatrix
-vertcat__3 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertcat__3 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertcat__4" c_vertcat__4
- :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
-{-|
->Concatenate a list of matrices horizontally Alternative terminology:
->horizontal stack, hstack, horizontal append, [a b].
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertcat__4
- :: Vector IMatrix -> IO IMatrix
-vertcat__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertcat__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__0" c_vertsplit__0
- :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__0
- :: MX -> IO (Vector MX)
-vertsplit__0 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertsplit__0 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__1" c_vertsplit__1
- :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__1
- :: MX -> Int -> IO (Vector MX)
-vertsplit__1 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "vertsplit__2" c_vertsplit__2
- :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
-{-|
->split horizontally, retaining groups of rows
->
->Parameters:
->-----------
->
->output_offset: List of all start rows for each group the last row group
->will run to the end.
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__2
- :: MX -> Vector Int -> IO (Vector MX)
-vertsplit__2 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "vertsplit__3" c_vertsplit__3
- :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
-{-|
->Split up a sparsity pattern vertically.
--}
-vertsplit__3
- :: Sparsity -> Vector Int -> IO (Vector Sparsity)
-vertsplit__3 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertsplit__3 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__4" c_vertsplit__4
- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__4
- :: SX -> IO (Vector SX)
-vertsplit__4 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertsplit__4 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__5" c_vertsplit__5
- :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__5
- :: SX -> Int -> IO (Vector SX)
-vertsplit__5 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "vertsplit__6" c_vertsplit__6
- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
-{-|
->split horizontally, retaining groups of rows
->
->Parameters:
->-----------
->
->output_offset: List of all start rows for each group the last row group
->will run to the end.
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__6
- :: SX -> Vector Int -> IO (Vector SX)
-vertsplit__6 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertsplit__6 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__7" c_vertsplit__7
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__7
- :: DMatrix -> IO (Vector DMatrix)
-vertsplit__7 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertsplit__7 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__8" c_vertsplit__8
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__8
- :: DMatrix -> Int -> IO (Vector DMatrix)
-vertsplit__8 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "vertsplit__9" c_vertsplit__9
- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
-{-|
->split horizontally, retaining groups of rows
->
->Parameters:
->-----------
->
->output_offset: List of all start rows for each group the last row group
->will run to the end.
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__9
- :: DMatrix -> Vector Int -> IO (Vector DMatrix)
-vertsplit__9 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertsplit__9 errStrPtrP x0' x1'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__10" c_vertsplit__10
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__10
- :: IMatrix -> IO (Vector IMatrix)
-vertsplit__10 x0 =
- withMarshal x0 $ \x0' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_vertsplit__10 errStrPtrP x0'
- errStrPtr <- peek errStrPtrP
- free errStrPtrP
- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
-
-
-foreign import ccall unsafe "vertsplit__11" c_vertsplit__11
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
-{-|
->split horizontally, retaining fixed-sized groups of rows
->
->Parameters:
->-----------
->
->incr: Size of each group of rows
->
->vertcat(vertsplit(x, ...)) = x
--}
-vertsplit__11
- :: IMatrix -> Int -> IO (Vector IMatrix)
-vertsplit__11 x0 x1 =
- withMarshal x0 $ \x0' ->
- withMarshal x1 $ \x1' ->
- do
- errStrPtrP <- new nullPtr
- ret <- c_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 "vertsplit__12" c_vertsplit__12
- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
-{-|
->split horizontally, retaining groups of rows
+ blockcat__4,
+ blocksplit__0,
+ blocksplit__1,
+ blocksplit__10,
+ blocksplit__11,
+ blocksplit__12,
+ blocksplit__13,
+ blocksplit__14,
+ blocksplit__15,
+ blocksplit__2,
+ blocksplit__3,
+ blocksplit__4,
+ blocksplit__5,
+ blocksplit__6,
+ blocksplit__7,
+ blocksplit__8,
+ blocksplit__9,
+ 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,
+ cofactor__0,
+ cofactor__1,
+ cofactor__2,
+ collocationPoints__0,
+ collocationPoints__1,
+ complement,
+ compress__0,
+ compress__1,
+ 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,
+ cross__0,
+ cross__1,
+ cross__2,
+ cross__3,
+ cross__4,
+ cross__5,
+ cross__6,
+ cross__7,
+ 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,
+ dense__0,
+ dense__1,
+ dense__2,
+ dense__3,
+ dependsOn__0,
+ dependsOn__1,
+ det__0,
+ det__1,
+ det__2,
+ det__3,
+ diag__0,
+ diag__1,
+ diag__2,
+ diag__3,
+ diagcat,
+ diagsplit__0,
+ diagsplit__1,
+ diagsplit__10,
+ diagsplit__11,
+ diagsplit__12,
+ diagsplit__13,
+ diagsplit__14,
+ diagsplit__15,
+ diagsplit__16,
+ diagsplit__17,
+ diagsplit__18,
+ diagsplit__19,
+ diagsplit__2,
+ diagsplit__20,
+ diagsplit__21,
+ diagsplit__3,
+ diagsplit__4,
+ diagsplit__5,
+ diagsplit__6,
+ diagsplit__7,
+ diagsplit__8,
+ diagsplit__9,
+ 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,
+ explicitRK__0,
+ explicitRK__1,
+ explicitRK__2,
+ explicitRK__3,
+ extractShared__0,
+ extractShared__1,
+ extractShared__2,
+ extractShared__3,
+ extractShared__4,
+ extractShared__5,
+ gauss_quadrature__0,
+ gauss_quadrature__1,
+ gauss_quadrature__2,
+ getFree,
+ getMinor__0,
+ getMinor__1,
+ getMinor__2,
+ 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,
+ 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,
+ horzcat__0,
+ horzcat__1,
+ horzcat__2,
+ horzcat__3,
+ horzcat__4,
+ horzsplit__0,
+ horzsplit__1,
+ horzsplit__10,
+ horzsplit__11,
+ horzsplit__12,
+ horzsplit__2,
+ horzsplit__3,
+ horzsplit__4,
+ horzsplit__5,
+ horzsplit__6,
+ horzsplit__7,
+ horzsplit__8,
+ horzsplit__9,
+ if_else__0,
+ if_else__1,
+ implicitRK,
+ inner_prod__0,
+ inner_prod__1,
+ inner_prod__2,
+ inner_prod__3,
+ 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,
+ inv__0,
+ inv__1,
+ inv__2,
+ inv__3,
+ isDecreasing__0,
+ isDecreasing__1,
+ isEqual__0,
+ isEqual__1,
+ isEqual__2,
+ isEqual__3,
+ 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,
+ kron__0,
+ kron__1,
+ kron__2,
+ kron__3,
+ 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,
+ linspace__0,
+ linspace__1,
+ linspace__2,
+ logic_and__0,
+ logic_and__1,
+ logic_and__2,
+ logic_and__3,
+ logic_and__4,
+ logic_and__5,
+ logic_and__6,
+ logic_not__0,
+ logic_not__1,
+ logic_not__2,
+ logic_not__3,
+ logic_not__4,
+ logic_not__5,
+ logic_not__6,
+ logic_or__0,
+ logic_or__1,
+ logic_or__2,
+ logic_or__3,
+ logic_or__4,
+ logic_or__5,
+ logic_or__6,
+ 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,
+ mul__0,
+ mul__1,
+ mul__10,
+ mul__11,
+ mul__12,
+ mul__13,
+ mul__2,
+ mul__3,
+ mul__4,
+ mul__5,
+ mul__6,
+ mul__7,
+ mul__8,
+ mul__9,
+ 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,
+ norm_0_mul_nn__0,
+ norm_0_mul_nn__1,
+ norm_0_mul_nn__2,
+ norm_1__0,
+ norm_1__1,
+ norm_1__2,
+ norm_1__3,
+ norm_2__0,
+ norm_2__1,
+ norm_2__2,
+ norm_2__3,
+ norm_F__0,
+ norm_F__1,
+ norm_F__2,
+ norm_F__3,
+ norm_inf__0,
+ norm_inf__1,
+ norm_inf__2,
+ norm_inf__3,
+ norm_inf_mul_nn,
+ nullspace__0,
+ nullspace__1,
+ nullspace__2,
+ nullspace__3,
+ outer_prod__0,
+ outer_prod__1,
+ outer_prod__2,
+ outer_prod__3,
+ pinv__0,
+ pinv__1,
+ pinv__2,
+ pinv__3,
+ pinv__4,
+ poly_coeff,
+ poly_roots,
+ polyval__0,
+ polyval__1,
+ polyval__2,
+ polyval__3,
+ printCompact__0,
+ printCompact__1,
+ project__0,
+ project__1,
+ project__2,
+ 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,
+ quad_form__0,
+ quad_form__1,
+ quad_form__2,
+ quad_form__3,
+ quad_form__4,
+ quad_form__5,
+ quad_form__6,
+ quad_form__7,
+ ramp,
+ rank,
+ 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,
+ repmat__0,
+ repmat__1,
+ repmat__2,
+ repmat__3,
+ reshape__0,
+ reshape__1,
+ reshape__2,
+ reshape__3,
+ reshape__4,
+ reshape__5,
+ reshape__6,
+ reshape__7,
+ 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,
+ simplify__0,
+ simplify__1,
+ 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__3,
+ socpOut__4,
+ socpOut__5,
+ socpOut__6,
+ socpOut__7,
+ socpOut__8,
+ socpOut__9,
+ socpStruct__0,
+ socpStruct__1,
+ socpStruct__2,
+ solve__0,
+ solve__1,
+ solve__2,
+ solve__3,
+ solve__4,
+ solve__5,
+ sparse__0,
+ sparse__1,
+ sparse__2,
+ sparse__3,
+ sparse__4,
+ sparse__5,
+ sprank__0,
+ sprank__1,
+ sprank__2,
+ 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,
+ substitute__0,
+ substitute__1,
+ substitute__2,
+ substitute__3,
+ sumAll__0,
+ sumAll__1,
+ sumAll__2,
+ sumAll__3,
+ sumCols__0,
+ sumCols__1,
+ sumCols__2,
+ sumCols__3,
+ sumRows__0,
+ sumRows__1,
+ sumRows__2,
+ sumRows__3,
+ sum_square__0,
+ sum_square__1,
+ sum_square__2,
+ sum_square__3,
+ tangent__0,
+ tangent__1,
+ taylor__0,
+ taylor__1,
+ taylor__2,
+ trace__0,
+ trace__1,
+ trace__2,
+ trace__3,
+ transpose__0,
+ transpose__1,
+ transpose__2,
+ transpose__3,
+ transpose__4,
+ triangle,
+ tril2symm__0,
+ tril2symm__1,
+ tril2symm__2,
+ tril2symm__3,
+ tril__0,
+ tril__1,
+ tril__2,
+ tril__3,
+ tril__4,
+ tril__5,
+ triu2symm__0,
+ triu2symm__1,
+ triu2symm__2,
+ triu2symm__3,
+ triu__0,
+ triu__1,
+ triu__2,
+ triu__3,
+ triu__4,
+ triu__5,
+ unite__0,
+ unite__1,
+ unite__2,
+ unite__3,
+ vecNZ__0,
+ vecNZ__1,
+ vecNZ__2,
+ vecNZ__3,
+ vecNZcat__0,
+ vecNZcat__1,
+ vecNZcat__2,
+ vecNZcat__3,
+ vec__0,
+ vec__1,
+ vec__2,
+ vec__3,
+ vec__4,
+ veccat__0,
+ veccat__1,
+ veccat__2,
+ veccat__3,
+ vertcat__0,
+ vertcat__1,
+ vertcat__2,
+ vertcat__3,
+ vertcat__4,
+ vertsplit__0,
+ vertsplit__1,
+ vertsplit__10,
+ vertsplit__11,
+ vertsplit__12,
+ vertsplit__2,
+ vertsplit__3,
+ vertsplit__4,
+ vertsplit__5,
+ vertsplit__6,
+ vertsplit__7,
+ vertsplit__8,
+ vertsplit__9,
+ ) 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 "addMultiple__0" c_addMultiple__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> IO ()
+{-|
+>same as: res += mul(A, v)
+-}
+addMultiple__0
+ :: SX -> Vector SXElement -> Vector SXElement -> IO ()
+addMultiple__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_addMultiple__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 "addMultiple__1" c_addMultiple__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> CInt -> IO ()
+{-|
+>same as: res += mul(A, v)
+-}
+addMultiple__1
+ :: SX -> Vector SXElement -> Vector SXElement -> Bool -> IO ()
+addMultiple__1 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_addMultiple__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 "addMultiple__2" c_addMultiple__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> IO ()
+{-|
+>same as: res += mul(A, v)
+-}
+addMultiple__2
+ :: DMatrix -> Vector Double -> Vector Double -> IO ()
+addMultiple__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_addMultiple__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 "addMultiple__3" c_addMultiple__3
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CDouble) -> CInt -> IO ()
+{-|
+>same as: res += mul(A, v)
+-}
+addMultiple__3
+ :: DMatrix -> Vector Double -> Vector Double -> Bool -> IO ()
+addMultiple__3 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_addMultiple__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 "addMultiple__4" c_addMultiple__4
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO ()
+{-|
+>same as: res += mul(A, v)
+-}
+addMultiple__4
+ :: IMatrix -> Vector Int -> Vector Int -> IO ()
+addMultiple__4 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_addMultiple__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 "addMultiple__5" c_addMultiple__5
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> CInt -> IO ()
+{-|
+>same as: res += mul(A, v)
+-}
+addMultiple__5
+ :: IMatrix -> Vector Int -> Vector Int -> Bool -> IO ()
+addMultiple__5 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_addMultiple__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 "adj__0" c_adj__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Transpose of a matrix.
+-}
+adj__0
+ :: SX -> IO SX
+adj__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_adj__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "adj__1" c_adj__1
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Transpose of a matrix.
+-}
+adj__1
+ :: DMatrix -> IO DMatrix
+adj__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_adj__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "adj__2" c_adj__2
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Transpose of a matrix.
+-}
+adj__2
+ :: IMatrix -> IO IMatrix
+adj__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_adj__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blkdiag__0" c_blkdiag__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+{-|
+>Construct a matrix with given blocks on the diagonal.
+-}
+blkdiag__0
+ :: Vector MX -> IO MX
+blkdiag__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blkdiag__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blkdiag__1" c_blkdiag__1
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+{-|
+>Construct a Sparsity with given blocks on the diagonal.
+-}
+blkdiag__1
+ :: Vector Sparsity -> IO Sparsity
+blkdiag__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blkdiag__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blkdiag__2" c_blkdiag__2
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+{-|
+>Construct a matrix with given block on the diagonal.
+-}
+blkdiag__2
+ :: Vector SX -> IO SX
+blkdiag__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blkdiag__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blkdiag__3" c_blkdiag__3
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
+{-|
+>Construct a matrix with given block on the diagonal.
+-}
+blkdiag__3
+ :: Vector DMatrix -> IO DMatrix
+blkdiag__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blkdiag__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blkdiag__4" c_blkdiag__4
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
+{-|
+>Construct a matrix with given block on the diagonal.
+-}
+blkdiag__4
+ :: Vector IMatrix -> IO IMatrix
+blkdiag__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blkdiag__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blockcat__0" c_blockcat__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr MX')))) -> IO (Ptr MX')
+{-|
+>Construct a matrix from a list of list of blocks.
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blockcat__0
+ :: Vector (Vector MX) -> IO MX
+blockcat__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blockcat__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blockcat__1" c_blockcat__1
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr Sparsity')))) -> IO (Ptr Sparsity')
+{-|
+>Construct a sparsity from a list of list of sparsities.
+-}
+blockcat__1
+ :: Vector (Vector Sparsity) -> IO Sparsity
+blockcat__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blockcat__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blockcat__2" c_blockcat__2
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr SX')))) -> IO (Ptr SX')
+{-|
+>Construct a matrix from a list of list of blocks.
+-}
+blockcat__2
+ :: Vector (Vector SX) -> IO SX
+blockcat__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blockcat__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blockcat__3" c_blockcat__3
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))) -> IO (Ptr DMatrix')
+{-|
+>Construct a matrix from a list of list of blocks.
+-}
+blockcat__3
+ :: Vector (Vector DMatrix) -> IO DMatrix
+blockcat__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blockcat__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blockcat__4" c_blockcat__4
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))) -> IO (Ptr IMatrix')
+{-|
+>Construct a matrix from a list of list of blocks.
+-}
+blockcat__4
+ :: Vector (Vector IMatrix) -> IO IMatrix
+blockcat__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blockcat__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blocksplit__0" c_blocksplit__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+{-|
+>chop up into blocks
+>
+>vert_incr Defines the increment for block boundaries in col dimension
+>horz_incr Defines the increment for block boundaries in row dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__0
+ :: MX -> IO (Vector (Vector MX))
+blocksplit__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blocksplit__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blocksplit__1" c_blocksplit__1
+ :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+{-|
+>chop up into blocks
+>
+>vert_incr Defines the increment for block boundaries in col dimension
+>horz_incr Defines the increment for block boundaries in row dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__1
+ :: MX -> Int -> IO (Vector (Vector MX))
+blocksplit__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__2" c_blocksplit__2
+ :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+{-|
+>chop up into blocks
+>
+>vert_incr Defines the increment for block boundaries in col dimension
+>horz_incr Defines the increment for block boundaries in row dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__2
+ :: MX -> Int -> Int -> IO (Vector (Vector MX))
+blocksplit__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__3" c_blocksplit__3
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr MX')))))
+{-|
+>chop up into blocks
+>
+>vert_offset Defines the boundaries of the block cols horz_offset Defines the
+>boundaries of the block rows
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__3
+ :: MX -> Vector Int -> Vector Int -> IO (Vector (Vector MX))
+blocksplit__3 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__4" c_blocksplit__4
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__4
+ :: SX -> IO (Vector (Vector SX))
+blocksplit__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blocksplit__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blocksplit__5" c_blocksplit__5
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__5
+ :: SX -> Int -> IO (Vector (Vector SX))
+blocksplit__5 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__6" c_blocksplit__6
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__6
+ :: SX -> Int -> Int -> IO (Vector (Vector SX))
+blocksplit__6 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__7" c_blocksplit__7
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr SX')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_offset: Defines the boundaries of the block rows
+>
+>horz_offset: Defines the boundaries of the block columns
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__7
+ :: SX -> Vector Int -> Vector Int -> IO (Vector (Vector SX))
+blocksplit__7 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__8" c_blocksplit__8
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__8
+ :: DMatrix -> IO (Vector (Vector DMatrix))
+blocksplit__8 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blocksplit__8 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blocksplit__9" c_blocksplit__9
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__9
+ :: DMatrix -> Int -> IO (Vector (Vector DMatrix))
+blocksplit__9 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__10" c_blocksplit__10
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__10
+ :: DMatrix -> Int -> Int -> IO (Vector (Vector DMatrix))
+blocksplit__10 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__11" c_blocksplit__11
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr DMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_offset: Defines the boundaries of the block rows
+>
+>horz_offset: Defines the boundaries of the block columns
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__11
+ :: DMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector DMatrix))
+blocksplit__11 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__12" c_blocksplit__12
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__12
+ :: IMatrix -> IO (Vector (Vector IMatrix))
+blocksplit__12 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_blocksplit__12 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "blocksplit__13" c_blocksplit__13
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__13
+ :: IMatrix -> Int -> IO (Vector (Vector IMatrix))
+blocksplit__13 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__14" c_blocksplit__14
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_incr: Defines the increment for block boundaries in row dimension
+>
+>horz_incr: Defines the increment for block boundaries in column dimension
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__14
+ :: IMatrix -> Int -> Int -> IO (Vector (Vector IMatrix))
+blocksplit__14 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "blocksplit__15" c_blocksplit__15
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr (StdVec (Ptr IMatrix')))))
+{-|
+>chop up into blocks
+>
+>Parameters:
+>-----------
+>
+>vert_offset: Defines the boundaries of the block rows
+>
+>horz_offset: Defines the boundaries of the block columns
+>
+>blockcat(blocksplit(x,..., ...)) = x
+-}
+blocksplit__15
+ :: IMatrix -> Vector Int -> Vector Int -> IO (Vector (Vector IMatrix))
+blocksplit__15 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "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 "cofactor__0" c_cofactor__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SXElement')
+{-|
+>Transpose of a matrix.
+-}
+cofactor__0
+ :: SX -> Int -> Int -> IO SXElement
+cofactor__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cofactor__1" c_cofactor__1
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO CDouble
+{-|
+>Transpose of a matrix.
+-}
+cofactor__1
+ :: DMatrix -> Int -> Int -> IO Double
+cofactor__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cofactor__2" c_cofactor__2
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt
+{-|
+>Transpose of a matrix.
+-}
+cofactor__2
+ :: IMatrix -> Int -> Int -> IO Int
+cofactor__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "collocationPoints__0" c_collocationPoints__0
+ :: Ptr (Ptr StdString) -> CInt -> IO (Ptr (StdVec CDouble))
+{-|
+>Obtain collocation points of specific order and scheme.
+>
+>Parameters:
+>-----------
+>
+>scheme: 'radau' or 'legendre'
+-}
+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))
+{-|
+>Obtain collocation points of specific order and scheme.
+>
+>Parameters:
+>-----------
+>
+>scheme: 'radau' or 'legendre'
+-}
+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))
+{-|
+>Returns the list of all i in [0, size[ not found in supplied list.
+>
+>The supplied vector may contain duplicates and may be non-monotonous The
+>supplied vector will be checked for bounds The result vector is guaranteed
+>to be monotonously increasing
+-}
+complement
+ :: Vector Int -> Int -> IO (Vector Int)
+complement x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ 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 "compress__0" c_compress__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+{-|
+>Remove identical calculations.
+-}
+compress__0
+ :: SX -> IO ()
+compress__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_compress__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "compress__1" c_compress__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO ()
+{-|
+>Remove identical calculations.
+-}
+compress__1
+ :: SX -> Int -> IO ()
+compress__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_compress__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__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
+{-|
+>Count number of nodes
+-}
+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
+{-|
+>Count number of nodes.
+-}
+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')
+{-|
+>Create a parent MX on which a bunch of MX's (sizes given as argument) will
+>depend.
+-}
+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')
+{-|
+>Create a parent MX on which a bunch of MX's (sizes given as argument) will
+>depend.
+-}
+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')
+{-|
+>Create a parent MX on which all given MX's will depend.
+>
+>In some sense, this function is the inverse of
+>
+>Parameters:
+>-----------
+>
+>deps: Must all be symbolic matrices.
+-}
+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 "cross__0" c_cross__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Matlab's cross command.
+-}
+cross__0
+ :: MX -> MX -> IO MX
+cross__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cross__1" c_cross__1
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
+{-|
+>Matlab's cross command.
+-}
+cross__1
+ :: MX -> MX -> Int -> IO MX
+cross__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cross__2" c_cross__2
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Matlab's cross command.
+-}
+cross__2
+ :: SX -> SX -> IO SX
+cross__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cross__3" c_cross__3
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+{-|
+>Matlab's cross command.
+-}
+cross__3
+ :: SX -> SX -> Int -> IO SX
+cross__3 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cross__4" c_cross__4
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Matlab's cross command.
+-}
+cross__4
+ :: DMatrix -> DMatrix -> IO DMatrix
+cross__4 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cross__5" c_cross__5
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
+{-|
+>Matlab's cross command.
+-}
+cross__5
+ :: DMatrix -> DMatrix -> Int -> IO DMatrix
+cross__5 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cross__6" c_cross__6
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Matlab's cross command.
+-}
+cross__6
+ :: IMatrix -> IMatrix -> IO IMatrix
+cross__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "cross__7" c_cross__7
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> CInt -> IO (Ptr IMatrix')
+{-|
+>Matlab's cross command.
+-}
+cross__7
+ :: IMatrix -> IMatrix -> Int -> IO IMatrix
+cross__7 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "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 "dense__0" c_dense__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>create a clipped view into a matrix Create a sparse matrix from a dense
+>matrix A, with sparsity pattern sp
+>
+>MX clip(const MX& A, const Sparsity& sp) { Join the sparsity patterns
+>std::vector mapping; Sparsity sp = A.sparsity().patternIntersection(sp,
+>mapping);
+>
+>Split up the mapping std::vector nzA, nzB;
+>
+>Copy sparsity for (int k=0; knzA.push_back(k); } else if (mapping[k]>0) { nzB.push_back(k); } else {
+>throw CasadiException("Pattern intersection not empty"); } }
+>
+>Create mapping MX ret; ret.assignNode(new Mapping(sp)); ret->assign(A,
+>range(nzA.size()), nzA); ret->assign(B, range(nzB.size()), nzB); return ret;
+>
+>}
+>
+>Make the matrix dense if not already
+-}
+dense__0
+ :: MX -> IO MX
+dense__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_dense__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "dense__1" c_dense__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Make a matrix dense.
+-}
+dense__1
+ :: SX -> IO SX
+dense__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_dense__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "dense__2" c_dense__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Make a matrix dense.
+-}
+dense__2
+ :: DMatrix -> IO DMatrix
+dense__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_dense__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "dense__3" c_dense__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Make a matrix dense.
+-}
+dense__3
+ :: IMatrix -> IO IMatrix
+dense__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_dense__3 errStrPtrP x0'
+ 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
+{-|
+>Check if expression depends on any of the arguments The arguments must be
+>symbolic.
+-}
+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
+{-|
+>Check if expression depends on the argument The argument must be symbolic.
+-}
+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 "det__0" c_det__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Matrix determinant (experimental)
+-}
+det__0
+ :: MX -> IO MX
+det__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_det__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "det__1" c_det__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SXElement')
+{-|
+>Transpose of a matrix.
+-}
+det__1
+ :: SX -> IO SXElement
+det__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_det__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "det__2" c_det__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CDouble
+{-|
+>Transpose of a matrix.
+-}
+det__2
+ :: DMatrix -> IO Double
+det__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_det__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "det__3" c_det__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
+{-|
+>Transpose of a matrix.
+-}
+det__3
+ :: IMatrix -> IO Int
+det__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_det__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diag__0" c_diag__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Get the diagonal of a matrix or construct a diagonal.
+>
+>When the input is square, the diagonal elements are returned. If the input
+>is vector-like, a diagonal matrix is constructed with it.
+-}
+diag__0
+ :: MX -> IO MX
+diag__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diag__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diag__1" c_diag__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Get the diagonal of a matrix or construct a diagonal When the input is
+>square, the diagonal elements are returned. If the input is vector- like, a
+>diagonal matrix is constructed with it.
+-}
+diag__1
+ :: SX -> IO SX
+diag__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diag__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diag__2" c_diag__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Get the diagonal of a matrix or construct a diagonal When the input is
+>square, the diagonal elements are returned. If the input is vector- like, a
+>diagonal matrix is constructed with it.
+-}
+diag__2
+ :: DMatrix -> IO DMatrix
+diag__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diag__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diag__3" c_diag__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Get the diagonal of a matrix or construct a diagonal When the input is
+>square, the diagonal elements are returned. If the input is vector- like, a
+>diagonal matrix is constructed with it.
+-}
+diag__3
+ :: IMatrix -> IO IMatrix
+diag__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diag__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagcat" c_diagcat
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+{-|
+>concatenate diagonally
+>
+>diagcat(diagsplit(x, ...)) = x
+-}
+diagcat
+ :: Vector MX -> IO MX
+diagcat x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagcat errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__0" c_diagsplit__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split diagonally, retaining matrices
+>
+>Parameters:
+>-----------
+>
+>output_offset1: List of all start locations (row) for each matrix
+>
+>output_offset1: List of all start locations (column) for each matrix the
+>last matrix will run to the end. diagcat(diagsplit(x, ...)) = x
+-}
+diagsplit__0
+ :: MX -> Vector Int -> Vector Int -> IO (Vector MX)
+diagsplit__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "diagsplit__1" c_diagsplit__1
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+{-|
+>split diagonally, retaining square matrices
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start locations for each group the last matrix
+>will run to the end.
+>
+>diagcat(diagsplit(x, ...)) = x
+-}
+diagsplit__1
+ :: Sparsity -> Vector Int -> IO (Vector Sparsity)
+diagsplit__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__2" c_diagsplit__2
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
+{-|
+>split diagonally, retaining fixed-sized matrices
+>
+>Parameters:
+>-----------
+>
+>incr1: Row dimension of each matrix
+>
+>incr2: Column dimension of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__2
+ :: Sparsity -> Int -> Int -> IO (Vector Sparsity)
+diagsplit__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__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 "diagsplit__3" c_diagsplit__3
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr (StdVec (Ptr Sparsity')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__3
+ :: Sparsity -> IO (Vector Sparsity)
+diagsplit__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__4" c_diagsplit__4
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr (StdVec (Ptr Sparsity')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__4
+ :: Sparsity -> Int -> IO (Vector Sparsity)
+diagsplit__4 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__4 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__5" c_diagsplit__5
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+{-|
+>Split up a sparsity pattern diagonally.
+-}
+diagsplit__5
+ :: Sparsity -> Vector Int -> Vector Int -> IO (Vector Sparsity)
+diagsplit__5 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "diagsplit__6" c_diagsplit__6
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split diagonally, retaining square matrices
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start locations for each group the last matrix
+>will run to the end.
+>
+>diagcat(diagsplit(x, ...)) = x
+-}
+diagsplit__6
+ :: MX -> Vector Int -> IO (Vector MX)
+diagsplit__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__6 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__7" c_diagsplit__7
+ :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split diagonally, retaining fixed-sized matrices
+>
+>Parameters:
+>-----------
+>
+>incr1: Row dimension of each matrix
+>
+>incr2: Column dimension of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__7
+ :: MX -> Int -> Int -> IO (Vector MX)
+diagsplit__7 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__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 "diagsplit__8" c_diagsplit__8
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__8
+ :: MX -> IO (Vector MX)
+diagsplit__8 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__8 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__9" c_diagsplit__9
+ :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__9
+ :: MX -> Int -> IO (Vector MX)
+diagsplit__9 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__9 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__10" c_diagsplit__10
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split diagonally, retaining square matrices
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start locations for each group the last matrix
+>will run to the end.
+>
+>diagcat(diagsplit(x, ...)) = x
+-}
+diagsplit__10
+ :: SX -> Vector Int -> IO (Vector SX)
+diagsplit__10 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__10 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__11" c_diagsplit__11
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split diagonally, retaining fixed-sized matrices
+>
+>Parameters:
+>-----------
+>
+>incr1: Row dimension of each matrix
+>
+>incr2: Column dimension of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__11
+ :: SX -> Int -> Int -> IO (Vector SX)
+diagsplit__11 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__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 "diagsplit__12" c_diagsplit__12
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__12
+ :: SX -> IO (Vector SX)
+diagsplit__12 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__12 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__13" c_diagsplit__13
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__13
+ :: SX -> Int -> IO (Vector SX)
+diagsplit__13 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "diagsplit__14" c_diagsplit__14
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split diagonally, retaining square matrices
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start locations for each group the last matrix
+>will run to the end.
+>
+>diagcat(diagsplit(x, ...)) = x
+-}
+diagsplit__14
+ :: DMatrix -> Vector Int -> IO (Vector DMatrix)
+diagsplit__14 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__14 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__15" c_diagsplit__15
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split diagonally, retaining fixed-sized matrices
+>
+>Parameters:
+>-----------
+>
+>incr1: Row dimension of each matrix
+>
+>incr2: Column dimension of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__15
+ :: DMatrix -> Int -> Int -> IO (Vector DMatrix)
+diagsplit__15 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "diagsplit__16" c_diagsplit__16
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__16
+ :: DMatrix -> IO (Vector DMatrix)
+diagsplit__16 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__16 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__17" c_diagsplit__17
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__17
+ :: DMatrix -> Int -> IO (Vector DMatrix)
+diagsplit__17 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "diagsplit__18" c_diagsplit__18
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split diagonally, retaining square matrices
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start locations for each group the last matrix
+>will run to the end.
+>
+>diagcat(diagsplit(x, ...)) = x
+-}
+diagsplit__18
+ :: IMatrix -> Vector Int -> IO (Vector IMatrix)
+diagsplit__18 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "diagsplit__19" c_diagsplit__19
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split diagonally, retaining fixed-sized matrices
+>
+>Parameters:
+>-----------
+>
+>incr1: Row dimension of each matrix
+>
+>incr2: Column dimension of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__19
+ :: IMatrix -> Int -> Int -> IO (Vector IMatrix)
+diagsplit__19 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "diagsplit__20" c_diagsplit__20
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__20
+ :: IMatrix -> IO (Vector IMatrix)
+diagsplit__20 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__20 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "diagsplit__21" c_diagsplit__21
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split diagonally, retaining groups of square matrices
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each matrix
+>
+>diagsplit(diagsplit(x, ...)) = x
+-}
+diagsplit__21
+ :: IMatrix -> Int -> IO (Vector IMatrix)
+diagsplit__21 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_diagsplit__21 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')
+{-|
+>Attempts to find the eigenvalues of a symbolic matrix This will only work
+>for up to 3x3 matrices.
+>
+>Bring m in block diagonal form, calculating eigenvalues of each block
+>separately
+-}
+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')
+{-|
+>Substitute variable v with value vdef in an expression ex, and evaluate
+>numerically Note: this is not efficient. For critical parts (loops) of your
+>code, always use SXFunction.
+-}
+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')
+{-|
+>Evaluate an SX graph numerically Note: this is not efficient. For critical
+>parts (loops) of your code, always use SXFunction.
+-}
+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 the expression as a weighted sum (with constant weights)
+-}
+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 "explicitRK__0" c_explicitRK__0
+ :: Ptr (Ptr StdString) -> Ptr Function' -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f: dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
+>
+>+-----------+-------+----------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================+
+>| DAE_X | x | Differential state . |
+>+-----------+-------+----------------------------+
+>| DAE_Z | z | Algebraic state . |
+>+-----------+-------+----------------------------+
+>| DAE_P | p | Parameter . |
+>+-----------+-------+----------------------------+
+>| DAE_T | t | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
+>
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================================+
+>| DAE_ODE | ode | Right hand side of the implicit ODE . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG | alg | Right hand side of algebraic equations . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD | quad | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf: Integration end time
+>
+>order: Order of integration
+>
+>ne: Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__0
+ :: Function -> IO Function
+explicitRK__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_explicitRK__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "explicitRK__1" c_explicitRK__1
+ :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f: dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
+>
+>+-----------+-------+----------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================+
+>| DAE_X | x | Differential state . |
+>+-----------+-------+----------------------------+
+>| DAE_Z | z | Algebraic state . |
+>+-----------+-------+----------------------------+
+>| DAE_P | p | Parameter . |
+>+-----------+-------+----------------------------+
+>| DAE_T | t | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
+>
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================================+
+>| DAE_ODE | ode | Right hand side of the implicit ODE . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG | alg | Right hand side of algebraic equations . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD | quad | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf: Integration end time
+>
+>order: Order of integration
+>
+>ne: Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__1
+ :: Function -> MX -> IO Function
+explicitRK__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_explicitRK__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "explicitRK__2" c_explicitRK__2
+ :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f: dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
+>
+>+-----------+-------+----------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================+
+>| DAE_X | x | Differential state . |
+>+-----------+-------+----------------------------+
+>| DAE_Z | z | Algebraic state . |
+>+-----------+-------+----------------------------+
+>| DAE_P | p | Parameter . |
+>+-----------+-------+----------------------------+
+>| DAE_T | t | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
+>
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================================+
+>| DAE_ODE | ode | Right hand side of the implicit ODE . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG | alg | Right hand side of algebraic equations . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD | quad | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf: Integration end time
+>
+>order: Order of integration
+>
+>ne: Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__2
+ :: Function -> MX -> Int -> IO Function
+explicitRK__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_explicitRK__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 "explicitRK__3" c_explicitRK__3
+ :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr MX' -> CInt -> CInt -> IO (Ptr Function')
+{-|
+>Construct an explicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f: dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
+>
+>+-----------+-------+----------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================+
+>| DAE_X | x | Differential state . |
+>+-----------+-------+----------------------------+
+>| DAE_Z | z | Algebraic state . |
+>+-----------+-------+----------------------------+
+>| DAE_P | p | Parameter . |
+>+-----------+-------+----------------------------+
+>| DAE_T | t | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
+>
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================================+
+>| DAE_ODE | ode | Right hand side of the implicit ODE . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG | alg | Right hand side of algebraic equations . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD | quad | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf: Integration end time
+>
+>order: Order of integration
+>
+>ne: Number of times the RK primitive is repeated over the integration
+>interval
+-}
+explicitRK__3
+ :: Function -> MX -> Int -> Int -> IO Function
+explicitRK__3 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_explicitRK__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 "extractShared__0" c_extractShared__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> Ptr (StdVec (Ptr MX')) -> IO ()
+{-|
+>Extract shared subexpressions from an set of expressions.
+-}
+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 ()
+{-|
+>Extract shared subexpressions from an set of expressions.
+-}
+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 ()
+{-|
+>Extract shared subexpressions from an set of expressions.
+-}
+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 SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> IO ()
+{-|
+>Extract shared subexpressions from an set of expressions.
+-}
+extractShared__3
+ :: Vector SXElement -> Vector SXElement -> Vector SXElement -> 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 SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr StdString -> IO ()
+{-|
+>Extract shared subexpressions from an set of expressions.
+-}
+extractShared__4
+ :: Vector SXElement -> Vector SXElement -> Vector SXElement -> 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 SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr (StdVec (Ptr SXElement')) -> Ptr StdString -> Ptr StdString -> IO ()
+{-|
+>Extract shared subexpressions from an set of expressions.
+-}
+extractShared__5
+ :: Vector SXElement -> Vector SXElement -> Vector SXElement -> 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')
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+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')
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+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')
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+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')
+{-|
+>Get all the free variables in an expression.
+-}
+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 "getMinor__0" c_getMinor__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SXElement')
+{-|
+>Transpose of a matrix.
+-}
+getMinor__0
+ :: SX -> Int -> Int -> IO SXElement
+getMinor__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "getMinor__1" c_getMinor__1
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO CDouble
+{-|
+>Transpose of a matrix.
+-}
+getMinor__1
+ :: DMatrix -> Int -> Int -> IO Double
+getMinor__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "getMinor__2" c_getMinor__2
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO CInt
+{-|
+>Transpose of a matrix.
+-}
+getMinor__2
+ :: IMatrix -> Int -> Int -> IO Int
+getMinor__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "getOperatorRepresentation__0" c_getOperatorRepresentation__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
+{-|
+>Get a string representation for a binary MX, using custom arguments.
+-}
+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 SXElement' -> Ptr (StdVec (Ptr StdString)) -> IO (Ptr StdString)
+{-|
+>Get a string representation for a binary SX, using custom arguments.
+-}
+getOperatorRepresentation__1
+ :: SXElement -> 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')))
+{-|
+>Get all symbols contained in the supplied expression Get all symbols on
+>which the supplied expression depends.
+>
+>See: MXFunction::getFree()
+-}
+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')))
+{-|
+>Get all symbols contained in the supplied expression Get all symbols on
+>which the supplied expression depends.
+>
+>See: MXFunction::getFree()
+-}
+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 (StdVec (Ptr SXElement')))
+{-|
+>Get all symbols contained in the supplied expression Get all symbols on
+>which the supplied expression depends.
+>
+>See: SXFunction::getFree()
+-}
+getSymbols__2
+ :: SX -> IO (Vector SXElement)
+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')
+{-|
+>split horizontally, retaining groups of cols
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start cols for each group the last col group
+>will run to the end.
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+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')
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+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')))
+{-|
+>Substitute variable var with expression expr in multiple expressions,
+>preserving nodes.
+-}
+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')
+{-|
+>Substitute variable v with expression vdef in an expression ex, preserving
+>nodes.
+-}
+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 function.
+>
+>\\\\[ \\\\begin {cases} H(x) = 0 & x<0 \\\\\\\\ H(x) = 1/2 & x=0 \\\\\\\\
+>H(x) = 1 & x>0 \\\\\\\\ \\\\end {cases} \\\\]
+-}
+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 SX' -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO ()
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+hessian__0
+ :: SX -> SX -> SX -> SX -> 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 SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+hessian__1
+ :: SX -> SX -> IO SX
+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 "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 "horzcat__0" c_horzcat__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+{-|
+>concatenate horizontally
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzcat__0
+ :: Vector MX -> IO MX
+horzcat__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzcat__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzcat__1" c_horzcat__1
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+{-|
+>Concatenate a list of sparsities horizontally Alternative terminology:
+>horizontal stack, hstack, horizontal append, [a b].
+-}
+horzcat__1
+ :: Vector Sparsity -> IO Sparsity
+horzcat__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzcat__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzcat__2" c_horzcat__2
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+{-|
+>Concatenate a list of matrices horizontally Alternative terminology:
+>horizontal stack, hstack, horizontal append, [a b].
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzcat__2
+ :: Vector SX -> IO SX
+horzcat__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzcat__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzcat__3" c_horzcat__3
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
+{-|
+>Concatenate a list of matrices horizontally Alternative terminology:
+>horizontal stack, hstack, horizontal append, [a b].
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzcat__3
+ :: Vector DMatrix -> IO DMatrix
+horzcat__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzcat__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzcat__4" c_horzcat__4
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
+{-|
+>Concatenate a list of matrices horizontally Alternative terminology:
+>horizontal stack, hstack, horizontal append, [a b].
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzcat__4
+ :: Vector IMatrix -> IO IMatrix
+horzcat__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzcat__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__0" c_horzsplit__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split horizontally, retaining fixed-sized groups of cols
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of cols
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__0
+ :: MX -> IO (Vector MX)
+horzsplit__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__1" c_horzsplit__1
+ :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split horizontally, retaining fixed-sized groups of cols
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of cols
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__1
+ :: MX -> Int -> IO (Vector MX)
+horzsplit__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "horzsplit__2" c_horzsplit__2
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split horizontally, retaining groups of cols
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start cols for each group the last col group
+>will run to the end.
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__2
+ :: MX -> Vector Int -> IO (Vector MX)
+horzsplit__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "horzsplit__3" c_horzsplit__3
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+{-|
+>Split up a sparsity pattern horizontally.
+-}
+horzsplit__3
+ :: Sparsity -> Vector Int -> IO (Vector Sparsity)
+horzsplit__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__3 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__4" c_horzsplit__4
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split horizontally, retaining fixed-sized groups of columns
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of columns
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__4
+ :: SX -> IO (Vector SX)
+horzsplit__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__5" c_horzsplit__5
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split horizontally, retaining fixed-sized groups of columns
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of columns
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__5
+ :: SX -> Int -> IO (Vector SX)
+horzsplit__5 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "horzsplit__6" c_horzsplit__6
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split horizontally, retaining groups of columns
+>
+>Parameters:
+>-----------
+>
+>offset: List of all start columns for each group the last column group will
+>run to the end.
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__6
+ :: SX -> Vector Int -> IO (Vector SX)
+horzsplit__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__6 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__7" c_horzsplit__7
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split horizontally, retaining fixed-sized groups of columns
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of columns
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__7
+ :: DMatrix -> IO (Vector DMatrix)
+horzsplit__7 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__7 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__8" c_horzsplit__8
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split horizontally, retaining fixed-sized groups of columns
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of columns
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__8
+ :: DMatrix -> Int -> IO (Vector DMatrix)
+horzsplit__8 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "horzsplit__9" c_horzsplit__9
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split horizontally, retaining groups of columns
+>
+>Parameters:
+>-----------
+>
+>offset: List of all start columns for each group the last column group will
+>run to the end.
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__9
+ :: DMatrix -> Vector Int -> IO (Vector DMatrix)
+horzsplit__9 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__9 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__10" c_horzsplit__10
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split horizontally, retaining fixed-sized groups of columns
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of columns
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__10
+ :: IMatrix -> IO (Vector IMatrix)
+horzsplit__10 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__10 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "horzsplit__11" c_horzsplit__11
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split horizontally, retaining fixed-sized groups of columns
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of columns
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__11
+ :: IMatrix -> Int -> IO (Vector IMatrix)
+horzsplit__11 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "horzsplit__12" c_horzsplit__12
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split horizontally, retaining groups of columns
+>
+>Parameters:
+>-----------
+>
+>offset: List of all start columns for each group the last column group will
+>run to the end.
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+horzsplit__12
+ :: IMatrix -> Vector Int -> IO (Vector IMatrix)
+horzsplit__12 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_horzsplit__12 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "if_else__0" c_if_else__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Branching on MX nodes Ternary operator, "cond ? if_true : if_false".
+-}
+if_else__0
+ :: MX -> MX -> MX -> IO MX
+if_else__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "if_else__1" c_if_else__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+if_else__1
+ :: SX -> SX -> SX -> IO SX
+if_else__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_if_else__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 "implicitRK" c_implicitRK
+ :: Ptr (Ptr StdString) -> Ptr Function' -> Ptr StdString -> IO (Ptr Function')
+{-|
+>Construct an implicit Runge-Kutta integrator.
+>
+>Parameters:
+>-----------
+>
+>f: dynamical system
+>
+>>Input scheme: casadi::DAEInput (DAE_NUM_IN = 4) [daeIn]
+>
+>+-----------+-------+----------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================+
+>| DAE_X | x | Differential state . |
+>+-----------+-------+----------------------------+
+>| DAE_Z | z | Algebraic state . |
+>+-----------+-------+----------------------------+
+>| DAE_P | p | Parameter . |
+>+-----------+-------+----------------------------+
+>| DAE_T | t | Explicit time dependence . |
+>+-----------+-------+----------------------------+
+>
+>>Output scheme: casadi::DAEOutput (DAE_NUM_OUT = 3) [daeOut]
+>
+>+-----------+-------+--------------------------------------------+
+>| Full name | Short | Description |
+>+===========+=======+============================================+
+>| DAE_ODE | ode | Right hand side of the implicit ODE . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_ALG | alg | Right hand side of algebraic equations . |
+>+-----------+-------+--------------------------------------------+
+>| DAE_QUAD | quad | Right hand side of quadratures equations . |
+>+-----------+-------+--------------------------------------------+
+>
+>Parameters:
+>-----------
+>
+>tf: Integration end time
+>
+>order: Order of integration
+>
+>scheme: Collocation scheme, as excepted by collocationPoints function.
+>
+>ne: Number of times the RK primitive is repeated over the integration
+>interval
+-}
+implicitRK
+ :: Function -> String -> IO Function
+implicitRK x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_implicitRK errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "inner_prod__0" c_inner_prod__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Take the inner product of two vectors Equals.
+>
+>with x and y vectors
+-}
+inner_prod__0
+ :: MX -> MX -> IO MX
+inner_prod__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "inner_prod__1" c_inner_prod__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Inner product of two matrices Equals.
+>
+>with x and y matrices of the same dimension
+-}
+inner_prod__1
+ :: SX -> SX -> IO SX
+inner_prod__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "inner_prod__2" c_inner_prod__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Inner product of two matrices Equals.
+>
+>with x and y matrices of the same dimension
+-}
+inner_prod__2
+ :: DMatrix -> DMatrix -> IO DMatrix
+inner_prod__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "inner_prod__3" c_inner_prod__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Inner product of two matrices Equals.
+>
+>with x and y matrices of the same dimension
+-}
+inner_prod__3
+ :: IMatrix -> IMatrix -> IO IMatrix
+inner_prod__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "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 "inv__0" c_inv__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Matrix inverse (experimental)
+-}
+inv__0
+ :: MX -> IO MX
+inv__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_inv__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "inv__1" c_inv__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Transpose of a matrix.
+-}
+inv__1
+ :: SX -> IO SX
+inv__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_inv__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "inv__2" c_inv__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Transpose of a matrix.
+-}
+inv__2
+ :: DMatrix -> IO DMatrix
+inv__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_inv__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "inv__3" c_inv__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Transpose of a matrix.
+-}
+inv__3
+ :: IMatrix -> IO IMatrix
+inv__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_inv__3 errStrPtrP x0'
+ 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
+{-|
+>Check if the vector is strictly decreasing.
+-}
+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
+{-|
+>Check if the vector is strictly decreasing.
+-}
+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 "isEqual__0" c_isEqual__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO CInt
+{-|
+>Check if two expressions are equal, assuming that they are comparable.
+-}
+isEqual__0
+ :: MX -> MX -> IO Bool
+isEqual__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "isEqual__1" c_isEqual__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO CInt
+{-|
+>Check if two expressions are equal, assuming that they are comparable.
+-}
+isEqual__1
+ :: SX -> SX -> IO Bool
+isEqual__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_isEqual__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "isEqual__2" c_isEqual__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO CInt
+{-|
+>Check if two expressions are equal, assuming that they are comparable.
+-}
+isEqual__2
+ :: DMatrix -> DMatrix -> IO Bool
+isEqual__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "isEqual__3" c_isEqual__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO CInt
+{-|
+>Check if two expressions are equal, assuming that they are comparable.
+-}
+isEqual__3
+ :: IMatrix -> IMatrix -> IO Bool
+isEqual__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_isEqual__3 errStrPtrP x0' x1'
+ 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
+{-|
+>Check if the vector is strictly increasing.
+-}
+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
+{-|
+>Check if the vector is strictly increasing.
+-}
+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
+{-|
+>Check if the vector is monotone.
+-}
+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
+{-|
+>Check if the vector is monotone.
+-}
+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
+{-|
+>Check if the vector is non-decreasing.
+-}
+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
+{-|
+>Check if the vector is non-decreasing.
+-}
+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
+{-|
+>Check if the vector is non-increasing.
+-}
+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
+{-|
+>Check if the vector is non-increasing.
+-}
+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
+{-|
+>Checks if vector does not contain NaN or Inf.
+-}
+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
+{-|
+>Checks if vector does not contain NaN or Inf.
+-}
+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
+{-|
+>Check if the vector is strictly monotone.
+-}
+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
+{-|
+>Check if the vector is strictly monotone.
+-}
+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')
+{-|
+>Calculate jacobian via source code transformation.
+>
+>Uses casadi::MXFunction::jac
+-}
+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')
+{-|
+>Calculate jacobian via source code transformation.
+>
+>Uses casadi::SXFunction::jac
+-}
+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')
+{-|
+>Calculate the Jacobian and multiply by a vector from the right This is
+>equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
+>transpose_jacobian set to false and true respectively. If contrast to these
+>expressions, it will use directional derivatives which is typically (but not
+>necessarily) more efficient if the complete Jacobian is not needed and v has
+>few rows.
+-}
+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')
+{-|
+>Calculate the Jacobian and multiply by a vector from the right This is
+>equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
+>transpose_jacobian set to false and true respectively. If contrast to these
+>expressions, it will use directional derivatives which is typically (but not
+>necessarily) more efficient if the complete Jacobian is not needed and v has
+>few rows.
+-}
+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 "kron__0" c_kron__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Kronecker tensor product.
+>
+>Creates a block matrix in which each element (i, j) is a_ij*b
+-}
+kron__0
+ :: MX -> MX -> IO MX
+kron__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "kron__1" c_kron__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Kronecker tensor product.
+>
+>Creates a block matrix in which each element (i, j) is a_ij*b
+-}
+kron__1
+ :: SX -> SX -> IO SX
+kron__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "kron__2" c_kron__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Kronecker tensor product.
+>
+>Creates a block matrix in which each element (i, j) is a_ij*b
+-}
+kron__2
+ :: DMatrix -> DMatrix -> IO DMatrix
+kron__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "kron__3" c_kron__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Kronecker tensor product.
+>
+>Creates a block matrix in which each element (i, j) is a_ij*b
+-}
+kron__3
+ :: IMatrix -> IMatrix -> IO IMatrix
+kron__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "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 "linspace__0" c_linspace__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> CInt -> IO (Ptr MX')
+{-|
+>Matlab's linspace command.
+-}
+linspace__0
+ :: MX -> MX -> Int -> IO MX
+linspace__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "linspace__1" c_linspace__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> CInt -> IO (Ptr SX')
+{-|
+>Matlab's linspace command.
+-}
+linspace__1
+ :: SX -> SX -> Int -> IO SX
+linspace__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "linspace__2" c_linspace__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> CInt -> IO (Ptr DMatrix')
+{-|
+>Matlab's linspace command.
+-}
+linspace__2
+ :: DMatrix -> DMatrix -> Int -> IO DMatrix
+linspace__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "logic_and__0" c_logic_and__0
+ :: Ptr (Ptr StdString) -> Ptr SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
+{-|
+>Logical and, returns (an expression evaluating to) 1 if both expressions are
+>nonzero and 0 otherwise.
+-}
+logic_and__0
+ :: SXElement -> SXElement -> IO SXElement
+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 MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Logical and, returns (an expression evaluating to) 1 if both expressions are
+>nonzero and 0 otherwise.
+-}
+logic_and__1
+ :: MX -> MX -> IO MX
+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 SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Logical and, returns (an expression evaluating to) 1 if both expressions are
+>nonzero and 0 otherwise.
+-}
+logic_and__2
+ :: SX -> SX -> IO SX
+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 DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Logical and, returns (an expression evaluating to) 1 if both expressions are
+>nonzero and 0 otherwise.
+-}
+logic_and__3
+ :: DMatrix -> DMatrix -> IO DMatrix
+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) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Logical and, returns (an expression evaluating to) 1 if both expressions are
+>nonzero and 0 otherwise.
+-}
+logic_and__4
+ :: IMatrix -> IMatrix -> IO IMatrix
+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) -> CDouble -> CDouble -> IO CDouble
+{-|
+>Logical and, returns (an expression evaluating to) 1 if both expressions are
+>nonzero and 0 otherwise.
+-}
+logic_and__5
+ :: Double -> Double -> IO Double
+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_and__6" c_logic_and__6
+ :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt
+{-|
+>Logical and, returns (an expression evaluating to) 1 if both expressions are
+>nonzero and 0 otherwise.
+-}
+logic_and__6
+ :: Int -> Int -> IO Int
+logic_and__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_logic_and__6 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 SXElement' -> IO (Ptr SXElement')
+{-|
+>Logical not, returns (an expression evaluating to) 1 if expression is zero
+>and 0 otherwise.
+-}
+logic_not__0
+ :: SXElement -> IO SXElement
+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 MX' -> IO (Ptr MX')
+{-|
+>Logical not, returns (an expression evaluating to) 1 if expression is zero
+>and 0 otherwise.
+-}
+logic_not__1
+ :: MX -> IO MX
+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 SX' -> IO (Ptr SX')
+{-|
+>Logical not, returns (an expression evaluating to) 1 if expression is zero
+>and 0 otherwise.
+-}
+logic_not__2
+ :: SX -> IO SX
+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 DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Logical not, returns (an expression evaluating to) 1 if expression is zero
+>and 0 otherwise.
+-}
+logic_not__3
+ :: DMatrix -> IO DMatrix
+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) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Logical not, returns (an expression evaluating to) 1 if expression is zero
+>and 0 otherwise.
+-}
+logic_not__4
+ :: IMatrix -> IO IMatrix
+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) -> CDouble -> IO CDouble
+{-|
+>Logical not, returns (an expression evaluating to) 1 if expression is zero
+>and 0 otherwise.
+-}
+logic_not__5
+ :: Double -> IO Double
+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_not__6" c_logic_not__6
+ :: Ptr (Ptr StdString) -> CInt -> IO CInt
+{-|
+>Logical not, returns (an expression evaluating to) 1 if expression is zero
+>and 0 otherwise.
+-}
+logic_not__6
+ :: Int -> IO Int
+logic_not__6 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_logic_not__6 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 SXElement' -> Ptr SXElement' -> IO (Ptr SXElement')
+{-|
+>Logical or, returns (an expression evaluating to) 1 if at least one
+>expression is nonzero and 0 otherwise.
+-}
+logic_or__0
+ :: SXElement -> SXElement -> IO SXElement
+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 MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Logical or, returns (an expression evaluating to) 1 if at least one
+>expression is nonzero and 0 otherwise.
+-}
+logic_or__1
+ :: MX -> MX -> IO MX
+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 SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Logical or, returns (an expression evaluating to) 1 if at least one
+>expression is nonzero and 0 otherwise.
+-}
+logic_or__2
+ :: SX -> SX -> IO SX
+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 DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Logical or, returns (an expression evaluating to) 1 if at least one
+>expression is nonzero and 0 otherwise.
+-}
+logic_or__3
+ :: DMatrix -> DMatrix -> IO DMatrix
+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) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Logical or, returns (an expression evaluating to) 1 if at least one
+>expression is nonzero and 0 otherwise.
+-}
+logic_or__4
+ :: IMatrix -> IMatrix -> IO IMatrix
+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) -> CDouble -> CDouble -> IO CDouble
+{-|
+>Logical or, returns (an expression evaluating to) 1 if at least one
+>expression is nonzero and 0 otherwise.
+-}
+logic_or__5
+ :: Double -> Double -> IO Double
+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 "logic_or__6" c_logic_or__6
+ :: Ptr (Ptr StdString) -> CInt -> CInt -> IO CInt
+{-|
+>Logical or, returns (an expression evaluating to) 1 if at least one
+>expression is nonzero and 0 otherwise.
+-}
+logic_or__6
+ :: Int -> Int -> IO Int
+logic_or__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_logic_or__6 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))
+{-|
+>Returns a vector for quickly looking up entries of supplied list.
+>
+>lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v contains
+>i
+>
+>Duplicates are treated by looking up last occurrence
+-}
+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')))
+{-|
+>Expand MX graph to SXFunction call.
+>
+>Expand the given expression e, optionally supplying expressions contained in
+>it at which expansion should stop.
+-}
+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')))
+{-|
+>Expand MX graph to SXFunction call.
+>
+>Expand the given expression e, optionally supplying expressions contained in
+>it at which expansion should stop.
+-}
+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')
+{-|
+>Expand MX graph to SXFunction call.
+>
+>Expand the given expression e, optionally supplying expressions contained in
+>it at which expansion should stop.
+-}
+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')
+{-|
+>Expand MX graph to SXFunction call.
+>
+>Expand the given expression e, optionally supplying expressions contained in
+>it at which expansion should stop.
+-}
+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')
+{-|
+>multivariate Taylor series expansion
+>
+>Do Taylor expansions until the aggregated order of a term is equal to
+>'order'. The aggregated order of $x^n y^m$ equals $n+m$.
+>
+>The argument order_contributions can denote how match each variable
+>contributes to the aggregated order. If x=[x, y] and order_contributions=[1,
+>2], then the aggregated order of $x^n y^m$ equals $1n+2m$.
+>
+>Example usage
+>
+>$ \\\\sin(b+a)+\\\\cos(b+a)(x-a)+\\\\cos(b+a)(y-b) $ $ y+x-(x^3+3y x^2+3 y^2
+>x+y^3)/6 $ $ (-3 x^2 y-x^3)/6+y+x $
+-}
+mtaylor__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')
+{-|
+>multivariate Taylor series expansion
+>
+>Do Taylor expansions until the aggregated order of a term is equal to
+>'order'. The aggregated order of $x^n y^m$ equals $n+m$.
+-}
+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')
+{-|
+>multivariate Taylor series expansion
+>
+>Do Taylor expansions until the aggregated order of a term is equal to
+>'order'. The aggregated order of $x^n y^m$ equals $n+m$.
+-}
+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 "mul__0" c_mul__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+{-|
+>Take the matrix product of n MX objects.
+-}
+mul__0
+ :: Vector MX -> IO MX
+mul__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "mul__1" c_mul__1
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Take the matrix product of 2 MX objects.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient then.
+-}
+mul__1
+ :: MX -> MX -> IO MX
+mul__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "mul__2" c_mul__2
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
+{-|
+>Take the matrix product of 2 MX objects.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient then.
+-}
+mul__2
+ :: MX -> MX -> Sparsity -> IO MX
+mul__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__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 "mul__3" c_mul__3
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+{-|
+>Get the sparsity resulting from a series of matrix multiplication.
+-}
+mul__3
+ :: Vector Sparsity -> IO Sparsity
+mul__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "mul__4" c_mul__4
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr Sparsity' -> IO (Ptr Sparsity')
+{-|
+>Get the sparsity resulting from a matrix multiplication.
+-}
+mul__4
+ :: Sparsity -> Sparsity -> IO Sparsity
+mul__4 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "mul__5" c_mul__5
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+{-|
+>Matrix product of n matrices.
+-}
+mul__5
+ :: Vector SX -> IO SX
+mul__5 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__5 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "mul__6" c_mul__6
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Matrix product of two matrices.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient in that case.
+-}
+mul__6
+ :: SX -> SX -> IO SX
+mul__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__6 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "mul__7" c_mul__7
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
+{-|
+>Matrix product of two matrices.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient in that case.
+-}
+mul__7
+ :: SX -> SX -> Sparsity -> IO SX
+mul__7 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__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 "mul__8" c_mul__8
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
+{-|
+>Matrix product of n matrices.
+-}
+mul__8
+ :: Vector DMatrix -> IO DMatrix
+mul__8 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__8 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "mul__9" c_mul__9
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Matrix product of two matrices.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient in that case.
+-}
+mul__9
+ :: DMatrix -> DMatrix -> IO DMatrix
+mul__9 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "mul__10" c_mul__10
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
+{-|
+>Matrix product of two matrices.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient in that case.
+-}
+mul__10
+ :: DMatrix -> DMatrix -> Sparsity -> IO DMatrix
+mul__10 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__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 "mul__11" c_mul__11
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
+{-|
+>Matrix product of n matrices.
+-}
+mul__11
+ :: Vector IMatrix -> IO IMatrix
+mul__11 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__11 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "mul__12" c_mul__12
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Matrix product of two matrices.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient in that case.
+-}
+mul__12
+ :: IMatrix -> IMatrix -> IO IMatrix
+mul__12 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__12 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "mul__13" c_mul__13
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
+{-|
+>Matrix product of two matrices.
+>
+>With optional sp_z you can specify the sparsity of the result A typical use
+>case might be where the product is only constructed to inspect the trace of
+>it. sp_z diagonal will be more efficient in that case.
+-}
+mul__13
+ :: IMatrix -> IMatrix -> Sparsity -> IO IMatrix
+mul__13 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_mul__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 "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 "norm_0_mul_nn__0" c_norm_0_mul_nn__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
+{-|
+>0-norm (nonzero count) of a Matrix-matrix product, no memory allocation
+>mul(x, y)
+>
+>Parameters:
+>-----------
+>
+>Bwork: A boolean work vector that you must allocate Minimum size: y.size1()
+>
+>Iwork: A integer work vector that you must allocate Minimum size:
+>y.size1()+x.size2()+1
+-}
+norm_0_mul_nn__0
+ :: SX -> SX -> Vector Bool -> Vector Int -> IO Int
+norm_0_mul_nn__0 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_norm_0_mul_nn__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 "norm_0_mul_nn__1" c_norm_0_mul_nn__1
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
+{-|
+>0-norm (nonzero count) of a Matrix-matrix product, no memory allocation
+>mul(x, y)
+>
+>Parameters:
+>-----------
+>
+>Bwork: A boolean work vector that you must allocate Minimum size: y.size1()
+>
+>Iwork: A integer work vector that you must allocate Minimum size:
+>y.size1()+x.size2()+1
+-}
+norm_0_mul_nn__1
+ :: DMatrix -> DMatrix -> Vector Bool -> Vector Int -> IO Int
+norm_0_mul_nn__1 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_norm_0_mul_nn__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 "norm_0_mul_nn__2" c_norm_0_mul_nn__2
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> Ptr (StdVec CInt) -> Ptr (StdVec CInt) -> IO CInt
+{-|
+>0-norm (nonzero count) of a Matrix-matrix product, no memory allocation
+>mul(x, y)
+>
+>Parameters:
+>-----------
+>
+>Bwork: A boolean work vector that you must allocate Minimum size: y.size1()
+>
+>Iwork: A integer work vector that you must allocate Minimum size:
+>y.size1()+x.size2()+1
+-}
+norm_0_mul_nn__2
+ :: IMatrix -> IMatrix -> Vector Bool -> Vector Int -> IO Int
+norm_0_mul_nn__2 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_norm_0_mul_nn__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 "norm_1__0" c_norm_1__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>1-norm
+-}
+norm_1__0
+ :: MX -> IO MX
+norm_1__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_1__1" c_norm_1__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>1-norm
+-}
+norm_1__1
+ :: SX -> IO SX
+norm_1__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_1__2" c_norm_1__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>1-norm
+-}
+norm_1__2
+ :: DMatrix -> IO DMatrix
+norm_1__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_1__3" c_norm_1__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>1-norm
+-}
+norm_1__3
+ :: IMatrix -> IO IMatrix
+norm_1__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_2__0" c_norm_2__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>2-norm
+-}
+norm_2__0
+ :: MX -> IO MX
+norm_2__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_2__1" c_norm_2__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>2-norm
+-}
+norm_2__1
+ :: SX -> IO SX
+norm_2__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_2__2" c_norm_2__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>2-norm
+-}
+norm_2__2
+ :: DMatrix -> IO DMatrix
+norm_2__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_2__3" c_norm_2__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>2-norm
+-}
+norm_2__3
+ :: IMatrix -> IO IMatrix
+norm_2__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_F__0" c_norm_F__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Frobenius norm.
+-}
+norm_F__0
+ :: MX -> IO MX
+norm_F__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_F__1" c_norm_F__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Frobenius norm.
+-}
+norm_F__1
+ :: SX -> IO SX
+norm_F__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_F__2" c_norm_F__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Frobenius norm.
+-}
+norm_F__2
+ :: DMatrix -> IO DMatrix
+norm_F__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_F__3" c_norm_F__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Frobenius norm.
+-}
+norm_F__3
+ :: IMatrix -> IO IMatrix
+norm_F__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_inf__0" c_norm_inf__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Infinity-norm.
+-}
+norm_inf__0
+ :: MX -> IO MX
+norm_inf__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_inf__1" c_norm_inf__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Infinity-norm.
+-}
+norm_inf__1
+ :: SX -> IO SX
+norm_inf__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_inf__2" c_norm_inf__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Infinity-norm.
+-}
+norm_inf__2
+ :: DMatrix -> IO DMatrix
+norm_inf__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_inf__3" c_norm_inf__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Infinity-norm.
+-}
+norm_inf__3
+ :: IMatrix -> IO IMatrix
+norm_inf__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "norm_inf_mul_nn" c_norm_inf_mul_nn
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> Ptr (StdVec CDouble) -> Ptr (StdVec CInt) -> IO CDouble
+{-|
+>Inf-norm of a Matrix-matrix product, no memory allocation mul(x, y)
+>
+>Parameters:
+>-----------
+>
+>Dwork: A double work vector that you must allocate Minimum size: y.size1()
+>
+>Iwork: A integer work vector that you must allocate Minimum size:
+>y.size1()+x.size2()+1
+-}
+norm_inf_mul_nn
+ :: DMatrix -> DMatrix -> Vector Double -> Vector Int -> IO Double
+norm_inf_mul_nn x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_norm_inf_mul_nn errStrPtrP x0' x1' x2' x3'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "nullspace__0" c_nullspace__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Computes the nullspace of a matrix A.
+>
+>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
+>
+>Assumes A is full rank
+>
+>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
+-}
+nullspace__0
+ :: MX -> IO MX
+nullspace__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_nullspace__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "nullspace__1" c_nullspace__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Computes the nullspace of a matrix A.
+>
+>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
+>
+>Assumes A is full rank
+>
+>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
+-}
+nullspace__1
+ :: SX -> IO SX
+nullspace__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_nullspace__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "nullspace__2" c_nullspace__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Computes the nullspace of a matrix A.
+>
+>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
+>
+>Assumes A is full rank
+>
+>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
+-}
+nullspace__2
+ :: DMatrix -> IO DMatrix
+nullspace__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_nullspace__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "nullspace__3" c_nullspace__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Computes the nullspace of a matrix A.
+>
+>Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
+>
+>Assumes A is full rank
+>
+>Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
+-}
+nullspace__3
+ :: IMatrix -> IO IMatrix
+nullspace__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_nullspace__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "outer_prod__0" c_outer_prod__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Take the outer product of two vectors Equals.
+>
+>with x and y vectors
+-}
+outer_prod__0
+ :: MX -> MX -> IO MX
+outer_prod__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "outer_prod__1" c_outer_prod__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Outer product of two vectors Equals.
+>
+>with x and y vectors
+-}
+outer_prod__1
+ :: SX -> SX -> IO SX
+outer_prod__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "outer_prod__2" c_outer_prod__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Outer product of two vectors Equals.
+>
+>with x and y vectors
+-}
+outer_prod__2
+ :: DMatrix -> DMatrix -> IO DMatrix
+outer_prod__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "outer_prod__3" c_outer_prod__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Outer product of two vectors Equals.
+>
+>with x and y vectors
+-}
+outer_prod__3
+ :: IMatrix -> IMatrix -> IO IMatrix
+outer_prod__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "pinv__0" c_pinv__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr StdString -> IO (Ptr MX')
+{-|
+>Computes the Moore-Penrose pseudo-inverse.
+>
+>If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size2 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')
+{-|
+>Computes the Moore-Penrose pseudo-inverse.
+>
+>If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size1 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')
+{-|
+>Computes the Moore-Penrose pseudo-inverse.
+>
+>If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size1 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')
+{-|
+>Computes the Moore-Penrose pseudo-inverse.
+>
+>If the matrix A is fat (size2>size1), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size1 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')
+{-|
+>Computes the Moore-Penrose pseudo-inverse.
+>
+>If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
+>matrix A is slender (size2 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')
+{-|
+>extracts polynomial coefficients from an expression
+>
+>ex Scalar expression that represents a polynomial x Scalar symbol that the
+>polynomial is build up with
+-}
+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')
+{-|
+>Attempts to find the roots of a polynomial.
+>
+>This will only work for polynomials up to order 3 It is assumed that the
+>roots are real.
+-}
+poly_roots
+ :: 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 "polyval__0" c_polyval__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Evaluate a polynomial with coefficients p in x.
+-}
+polyval__0
+ :: MX -> MX -> IO MX
+polyval__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "polyval__1" c_polyval__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Evaluate a polynomial with coefficients p in x.
+-}
+polyval__1
+ :: SX -> SX -> IO SX
+polyval__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "polyval__2" c_polyval__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Evaluate a polynomial with coefficients p in x.
+-}
+polyval__2
+ :: DMatrix -> DMatrix -> IO DMatrix
+polyval__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "polyval__3" c_polyval__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Evaluate a polynomial with coefficients p in x.
+-}
+polyval__3
+ :: IMatrix -> IMatrix -> IO IMatrix
+polyval__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "printCompact__0" c_printCompact__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
+{-|
+>Print compact, introducing new variables for shared subexpressions.
+-}
+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 ()
+{-|
+>Print compact, introducing new variables for shared subexpressions.
+-}
+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 "project__0" c_project__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
+{-|
+>Create a new matrix with a given sparsity pattern but with the nonzeros
+>taken from an existing matrix.
+-}
+project__0
+ :: SX -> Sparsity -> IO SX
+project__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "project__1" c_project__1
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
+{-|
+>Create a new matrix with a given sparsity pattern but with the nonzeros
+>taken from an existing matrix.
+-}
+project__1
+ :: DMatrix -> Sparsity -> IO DMatrix
+project__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_project__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "project__2" c_project__2
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
+{-|
+>Create a new matrix with a given sparsity pattern but with the nonzeros
+>taken from an existing matrix.
+-}
+project__2
+ :: IMatrix -> Sparsity -> IO IMatrix
+project__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "pw_const" c_pw_const
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Create a piecewise constant function Create a piecewise constant function
+>with n=val.size() intervals.
+>
+>Inputs:
+>
+>Parameters:
+>-----------
+>
+>t: a scalar variable (e.g. time)
+>
+>tval: vector with the discrete values of t at the interval transitions
+>(length n-1)
+>
+>val: vector with the value of the function for each interval (length n)
+-}
+pw_const
+ :: 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 SXElement' -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>t a scalar variable (e.g. time)
+>
+>Create a piecewise linear function Create a piecewise linear function:
+>
+>Inputs: tval vector with the the discrete values of t (monotonically
+>increasing) val vector with the corresponding function values (same length
+>as tval)
+-}
+pw_lin
+ :: SXElement -> 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 "quad_form__0" c_quad_form__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Calculate quadratic form X^T X.
+-}
+quad_form__0
+ :: MX -> IO MX
+quad_form__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "quad_form__1" c_quad_form__1
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Calculate quadratic form X^T A X.
+-}
+quad_form__1
+ :: MX -> MX -> IO MX
+quad_form__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "quad_form__2" c_quad_form__2
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Calculate quadratic form X^T X.
+-}
+quad_form__2
+ :: SX -> IO SX
+quad_form__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "quad_form__3" c_quad_form__3
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Calculate quadratic form X^T A X.
+-}
+quad_form__3
+ :: SX -> SX -> IO SX
+quad_form__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "quad_form__4" c_quad_form__4
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Calculate quadratic form X^T X.
+-}
+quad_form__4
+ :: DMatrix -> IO DMatrix
+quad_form__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "quad_form__5" c_quad_form__5
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Calculate quadratic form X^T A X.
+-}
+quad_form__5
+ :: DMatrix -> DMatrix -> IO DMatrix
+quad_form__5 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "quad_form__6" c_quad_form__6
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Calculate quadratic form X^T X.
+-}
+quad_form__6
+ :: IMatrix -> IO IMatrix
+quad_form__6 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "quad_form__7" c_quad_form__7
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Calculate quadratic form X^T A X.
+-}
+quad_form__7
+ :: IMatrix -> IMatrix -> IO IMatrix
+quad_form__7 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "ramp" c_ramp
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>ramp function
+>
+>\\\\[ \\\\begin {cases} R(x) = 0 & x <= 1 \\\\\\\\ R(x) = x & x > 1 \\\\\\\\
+>\\\\end {cases} \\\\]
+>
+>Also called: slope function
+-}
+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 "rank" c_rank
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO CInt
+{-|
+>Obtain the structural rank of a sparsity-pattern.
+-}
+rank
+ :: Sparsity -> IO Int
+rank x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_rank 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 function
+>
+>\\\\[ \\\\begin {cases} \\\\Pi(x) = 1 & |x| < 1/2 \\\\\\\\ \\\\Pi(x) = 1/2 &
+>|x| = 1/2 \\\\\\\\ \\\\Pi(x) = 0 & |x| > 1/2 \\\\\\\\ \\\\end {cases} \\\\]
+>
+>Also called: gate function, block function, band function, pulse function,
+>window function
+-}
+rectangle
+ :: 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 "repmat__0" c_repmat__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> CInt -> IO (Ptr MX')
+{-|
+>Repeat matrix A n times vertically and m times horizontally.
+-}
+repmat__0
+ :: MX -> Int -> Int -> IO MX
+repmat__0 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_repmat__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 "repmat__1" c_repmat__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+{-|
+>Repeat matrix A n times vertically and m times horizontally.
+-}
+repmat__1
+ :: SX -> Int -> Int -> IO SX
+repmat__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_repmat__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 "repmat__2" c_repmat__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
+{-|
+>Repeat matrix A n times vertically and m times horizontally.
+-}
+repmat__2
+ :: DMatrix -> Int -> Int -> IO DMatrix
+repmat__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "repmat__3" c_repmat__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
+{-|
+>Repeat matrix A n times vertically and m times horizontally.
+-}
+repmat__3
+ :: IMatrix -> Int -> Int -> IO IMatrix
+repmat__3 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_repmat__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 "reshape__0" c_reshape__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr Sparsity' -> IO (Ptr MX')
+{-|
+>Reshape the MX.
+-}
+reshape__0
+ :: MX -> Sparsity -> IO MX
+reshape__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "reshape__1" c_reshape__1
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> CInt -> IO (Ptr Sparsity')
+{-|
+>Reshape the sparsity pattern keeping the relative location of the nonzeros.
+-}
+reshape__1
+ :: Sparsity -> Int -> Int -> IO Sparsity
+reshape__1 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_reshape__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 "reshape__2" c_reshape__2
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr Sparsity' -> IO (Ptr SX')
+{-|
+>Transpose of a matrix.
+-}
+reshape__2
+ :: SX -> Sparsity -> IO SX
+reshape__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_reshape__2 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "reshape__3" c_reshape__3
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> CInt -> IO (Ptr SX')
+{-|
+>Transpose of a matrix.
+-}
+reshape__3
+ :: SX -> Int -> Int -> IO SX
+reshape__3 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_reshape__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 "reshape__4" c_reshape__4
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr Sparsity' -> IO (Ptr DMatrix')
+{-|
+>Transpose of a matrix.
+-}
+reshape__4
+ :: DMatrix -> Sparsity -> IO DMatrix
+reshape__4 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "reshape__5" c_reshape__5
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> CInt -> IO (Ptr DMatrix')
+{-|
+>Transpose of a matrix.
+-}
+reshape__5
+ :: DMatrix -> Int -> Int -> IO DMatrix
+reshape__5 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "reshape__6" c_reshape__6
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr Sparsity' -> IO (Ptr IMatrix')
+{-|
+>Transpose of a matrix.
+-}
+reshape__6
+ :: IMatrix -> Sparsity -> IO IMatrix
+reshape__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "reshape__7" c_reshape__7
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> CInt -> IO (Ptr IMatrix')
+{-|
+>Transpose of a matrix.
+-}
+reshape__7
+ :: IMatrix -> Int -> Int -> IO IMatrix
+reshape__7 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_reshape__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 "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 "simplify__0" c_simplify__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO ()
+{-|
+>Simplify an expression.
+-}
+simplify__0
+ :: MX -> IO ()
+simplify__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_simplify__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "simplify__1" c_simplify__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO ()
+{-|
+>Simplify an expression.
+-}
+simplify__1
+ :: SX -> IO ()
+simplify__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_simplify__1 errStrPtrP x0'
+ 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 DMatrix')) -> IO (Ptr (StdVec (Ptr DMatrix')))
+socpOut__5
+ :: Vector DMatrix -> IO (Vector DMatrix)
+socpOut__5 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__5 errStrPtrP x0'
+ 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 DMatrix')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix')))
+socpOut__6
+ :: Vector DMatrix -> String -> IO (Vector DMatrix)
+socpOut__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__6 errStrPtrP x0' x1'
+ 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')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix')))
+socpOut__7
+ :: Vector DMatrix -> String -> String -> IO (Vector DMatrix)
+socpOut__7 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__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 "socpOut__8" c_socpOut__8
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix')))
+socpOut__8
+ :: Vector DMatrix -> String -> String -> String -> IO (Vector DMatrix)
+socpOut__8 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__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 "socpOut__9" c_socpOut__9
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr DMatrix')))
+socpOut__9
+ :: Vector DMatrix -> String -> String -> String -> String -> IO (Vector DMatrix)
+socpOut__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_socpOut__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 "socpOut__10" c_socpOut__10
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr (StdVec (Ptr MX')))
+socpOut__10
+ :: Vector MX -> IO (Vector MX)
+socpOut__10 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__10 errStrPtrP x0'
+ 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 MX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
+socpOut__11
+ :: Vector MX -> String -> IO (Vector MX)
+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 (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
+socpOut__12
+ :: Vector MX -> String -> String -> IO (Vector MX)
+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 (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
+socpOut__13
+ :: Vector MX -> String -> String -> String -> IO (Vector MX)
+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 (StdVec (Ptr MX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr MX')))
+socpOut__14
+ :: Vector MX -> String -> String -> String -> String -> IO (Vector MX)
+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 (StdVec (Ptr SX')) -> IO (Ptr (StdVec (Ptr SX')))
+socpOut__15
+ :: Vector SX -> IO (Vector SX)
+socpOut__15 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__15 errStrPtrP x0'
+ 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 SX')) -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
+socpOut__16
+ :: Vector SX -> String -> IO (Vector SX)
+socpOut__16 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__16 errStrPtrP x0' x1'
+ 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 SX')) -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
+socpOut__17
+ :: Vector SX -> String -> String -> IO (Vector SX)
+socpOut__17 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__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 "socpOut__18" c_socpOut__18
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
+socpOut__18
+ :: Vector SX -> String -> String -> String -> IO (Vector SX)
+socpOut__18 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_socpOut__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 "socpOut__19" c_socpOut__19
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> Ptr StdString -> Ptr StdString -> Ptr StdString -> Ptr StdString -> IO (Ptr (StdVec (Ptr SX')))
+socpOut__19
+ :: Vector SX -> String -> String -> String -> String -> IO (Vector SX)
+socpOut__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_socpOut__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 "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 "solve__0" c_solve__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Solve a system of equations: A*x = b.
+-}
+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 a system of equations: A*x = b.
+-}
+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 a system of equations: A*x = b The solve routine works similar to
+>Matlab's backslash when A is square and nonsingular. The algorithm used is
+>the following:
+>
+>A simple forward or backward substitution if A is upper or lower triangular
+>
+>If the linear system is at most 3-by-3, form the inverse via minor expansion
+>and multiply
+>
+>Permute the variables and equations as to get a (structurally) nonzero
+>diagonal, then perform a QR factorization without pivoting and solve the
+>factorized system.
+>
+>Note 1: If there are entries of the linear system known to be zero, these
+>will be removed. Elements that are very small, or will evaluate to be zero,
+>can still cause numerical errors, due to the lack of pivoting (which is not
+>possible since cannot compare the size of entries)
+>
+>Note 2: When permuting the linear system, a BLT (block lower triangular)
+>transformation is formed. Only the permutation part of this is however used.
+>An improvement would be to solve block-by-block if there are multiple BLT
+>blocks.
+-}
+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 a system of equations: A*x = b The solve routine works similar to
+>Matlab's backslash when A is square and nonsingular. The algorithm used is
+>the following:
+>
+>A simple forward or backward substitution if A is upper or lower triangular
+>
+>If the linear system is at most 3-by-3, form the inverse via minor expansion
+>and multiply
+>
+>Permute the variables and equations as to get a (structurally) nonzero
+>diagonal, then perform a QR factorization without pivoting and solve the
+>factorized system.
+>
+>Note 1: If there are entries of the linear system known to be zero, these
+>will be removed. Elements that are very small, or will evaluate to be zero,
+>can still cause numerical errors, due to the lack of pivoting (which is not
+>possible since cannot compare the size of entries)
+>
+>Note 2: When permuting the linear system, a BLT (block lower triangular)
+>transformation is formed. Only the permutation part of this is however used.
+>An improvement would be to solve block-by-block if there are multiple BLT
+>blocks.
+-}
+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 a system of equations: A*x = b The solve routine works similar to
+>Matlab's backslash when A is square and nonsingular. The algorithm used is
+>the following:
+>
+>A simple forward or backward substitution if A is upper or lower triangular
+>
+>If the linear system is at most 3-by-3, form the inverse via minor expansion
+>and multiply
+>
+>Permute the variables and equations as to get a (structurally) nonzero
+>diagonal, then perform a QR factorization without pivoting and solve the
+>factorized system.
+>
+>Note 1: If there are entries of the linear system known to be zero, these
+>will be removed. Elements that are very small, or will evaluate to be zero,
+>can still cause numerical errors, due to the lack of pivoting (which is not
+>possible since cannot compare the size of entries)
+>
+>Note 2: When permuting the linear system, a BLT (block lower triangular)
+>transformation is formed. Only the permutation part of this is however used.
+>An improvement would be to solve block-by-block if there are multiple BLT
+>blocks.
+-}
+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 a system of equations: A*x = b.
+-}
+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 "sparse__0" c_sparse__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Make a matrix sparse by removing numerical zeros.
+-}
+sparse__0
+ :: SX -> IO SX
+sparse__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sparse__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sparse__1" c_sparse__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CDouble -> IO (Ptr SX')
+{-|
+>Make a matrix sparse by removing numerical zeros.
+-}
+sparse__1
+ :: SX -> Double -> IO SX
+sparse__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sparse__1 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sparse__2" c_sparse__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Make a matrix sparse by removing numerical zeros.
+-}
+sparse__2
+ :: DMatrix -> IO DMatrix
+sparse__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sparse__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sparse__3" c_sparse__3
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CDouble -> IO (Ptr DMatrix')
+{-|
+>Make a matrix sparse by removing numerical zeros.
+-}
+sparse__3
+ :: DMatrix -> Double -> IO DMatrix
+sparse__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sparse__3 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sparse__4" c_sparse__4
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Make a matrix sparse by removing numerical zeros.
+-}
+sparse__4
+ :: IMatrix -> IO IMatrix
+sparse__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sparse__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sparse__5" c_sparse__5
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CDouble -> IO (Ptr IMatrix')
+{-|
+>Make a matrix sparse by removing numerical zeros.
+-}
+sparse__5
+ :: IMatrix -> Double -> IO IMatrix
+sparse__5 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sparse__5 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sprank__0" c_sprank__0
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO CInt
+{-|
+>Obtain the structural rank of a sparsity-pattern.
+-}
+sprank__0
+ :: SX -> IO Int
+sprank__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sprank__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sprank__1" c_sprank__1
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CInt
+{-|
+>Obtain the structural rank of a sparsity-pattern.
+-}
+sprank__1
+ :: DMatrix -> IO Int
+sprank__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sprank__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sprank__2" c_sprank__2
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
+{-|
+>Obtain the structural rank of a sparsity-pattern.
+-}
+sprank__2
+ :: IMatrix -> IO Int
+sprank__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sprank__2 errStrPtrP x0'
+ 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')
+{-|
+>Get the sparsity pattern of a matrix.
+-}
+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 variable var with expression expr in multiple expressions.
+-}
+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 variable v with expression vdef in an expression ex.
+-}
+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 variable var with expression expr in multiple expressions.
+-}
+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 variable v with expression vdef in an expression ex.
+-}
+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 SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> IO ()
+{-|
+>Substitute variable var out of or into an expression expr, with an arbitrary
+>number of other expressions piggyback (vector version)
+-}
+substituteInPlace__0
+ :: Vector SX -> Vector SX -> Vector SX -> 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 SX')) -> Ptr (StdVec (Ptr SX')) -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
+{-|
+>Substitute variable var out of or into an expression expr, with an arbitrary
+>number of other expressions piggyback (vector version)
+-}
+substituteInPlace__1
+ :: Vector SX -> Vector SX -> Vector SX -> 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 SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> IO ()
+{-|
+>Substitute variable var out of or into an expression expr, with an arbitrary
+>number of other expressions piggyback.
+-}
+substituteInPlace__2
+ :: SX -> SX -> Vector SX -> IO ()
+substituteInPlace__2 x0 x1 x2 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "substituteInPlace__3" c_substituteInPlace__3
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> Ptr (StdVec (Ptr SX')) -> CInt -> IO ()
+{-|
+>Substitute variable var out of or into an expression expr, with an arbitrary
+>number of other expressions piggyback.
+-}
+substituteInPlace__3
+ :: SX -> SX -> Vector SX -> Bool -> IO ()
+substituteInPlace__3 x0 x1 x2 x3 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ withMarshal x2 $ \x2' ->
+ withMarshal x3 $ \x3' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "substituteInPlace__4" c_substituteInPlace__4
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO ()
+{-|
+>Substitute variable var out of or into an expression expr.
+-}
+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 ()
+{-|
+>Substitute variable var out of or into an expression expr.
+-}
+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 "sumAll__0" c_sumAll__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Return summation of all elements.
+-}
+sumAll__0
+ :: MX -> IO MX
+sumAll__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumAll__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumAll__1" c_sumAll__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Return summation of all elements.
+-}
+sumAll__1
+ :: SX -> IO SX
+sumAll__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumAll__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumAll__2" c_sumAll__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Return summation of all elements.
+-}
+sumAll__2
+ :: DMatrix -> IO DMatrix
+sumAll__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumAll__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumAll__3" c_sumAll__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Return summation of all elements.
+-}
+sumAll__3
+ :: IMatrix -> IO IMatrix
+sumAll__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumAll__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumCols__0" c_sumCols__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Return a col-wise summation of elements.
+-}
+sumCols__0
+ :: MX -> IO MX
+sumCols__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumCols__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumCols__1" c_sumCols__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Return a col-wise summation of elements.
+-}
+sumCols__1
+ :: SX -> IO SX
+sumCols__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumCols__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumCols__2" c_sumCols__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Return a col-wise summation of elements.
+-}
+sumCols__2
+ :: DMatrix -> IO DMatrix
+sumCols__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumCols__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumCols__3" c_sumCols__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Return a col-wise summation of elements.
+-}
+sumCols__3
+ :: IMatrix -> IO IMatrix
+sumCols__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumCols__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumRows__0" c_sumRows__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Return a row-wise summation of elements.
+-}
+sumRows__0
+ :: MX -> IO MX
+sumRows__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumRows__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumRows__1" c_sumRows__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Return a row-wise summation of elements.
+-}
+sumRows__1
+ :: SX -> IO SX
+sumRows__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumRows__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumRows__2" c_sumRows__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Return a row-wise summation of elements.
+-}
+sumRows__2
+ :: DMatrix -> IO DMatrix
+sumRows__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumRows__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sumRows__3" c_sumRows__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Return a row-wise summation of elements.
+-}
+sumRows__3
+ :: IMatrix -> IO IMatrix
+sumRows__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_sumRows__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "sum_square__0" c_sum_square__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Calculate some of squares: sum_ij X_ij^2.
+-}
+sum_square__0
+ :: MX -> IO MX
+sum_square__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "sum_square__1" c_sum_square__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Calculate some of squares: sum_ij X_ij^2.
+-}
+sum_square__1
+ :: SX -> IO SX
+sum_square__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "sum_square__2" c_sum_square__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Calculate some of squares: sum_ij X_ij^2.
+-}
+sum_square__2
+ :: DMatrix -> IO DMatrix
+sum_square__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "sum_square__3" c_sum_square__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Calculate some of squares: sum_ij X_ij^2.
+-}
+sum_square__3
+ :: IMatrix -> IO IMatrix
+sum_square__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "tangent__0" c_tangent__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>split horizontally, retaining groups of cols
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start cols for each group the last col group
+>will run to the end.
+>
+>horzcat(horzsplit(x, ...)) = x
+-}
+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')
+{-|
+>Integrate f from a to b using Gaussian quadrature with n points.
+-}
+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')
+{-|
+>univariate Taylor series expansion
+>
+>Calculate the Taylor expansion of expression 'ex' up to order 'order' with
+>respect to variable 'x' around the point 'a'
+>
+>$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
+>{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
+>
+>Example usage:
+>
+>::
+>
+>>> x
+-}
+taylor__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')
+{-|
+>univariate Taylor series expansion
+>
+>Calculate the Taylor expansion of expression 'ex' up to order 'order' with
+>respect to variable 'x' around the point 'a'
+>
+>$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
+>{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
+>
+>Example usage:
+>
+>::
+>
+>>> x
+-}
+taylor__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')
+{-|
+>univariate Taylor series expansion
+>
+>Calculate the Taylor expansion of expression 'ex' up to order 'order' with
+>respect to variable 'x' around the point 'a'
+>
+>$(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
+>{(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
+>
+>Example usage:
+>
+>::
+>
+>>> x
+-}
+taylor__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 "trace__0" c_trace__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Matrix trace.
+-}
+trace__0
+ :: MX -> IO MX
+trace__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_trace__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "trace__1" c_trace__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SXElement')
+{-|
+>Transpose of a matrix.
+-}
+trace__1
+ :: SX -> IO SXElement
+trace__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_trace__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "trace__2" c_trace__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO CDouble
+{-|
+>Transpose of a matrix.
+-}
+trace__2
+ :: DMatrix -> IO Double
+trace__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_trace__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "trace__3" c_trace__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO CInt
+{-|
+>Transpose of a matrix.
+-}
+trace__3
+ :: IMatrix -> IO Int
+trace__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_trace__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "transpose__0" c_transpose__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Transpose an expression.
+-}
+transpose__0
+ :: MX -> IO MX
+transpose__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_transpose__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "transpose__1" c_transpose__1
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+{-|
+>Transpose the pattern.
+-}
+transpose__1
+ :: Sparsity -> IO Sparsity
+transpose__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_transpose__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "transpose__2" c_transpose__2
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Transpose of a matrix.
+-}
+transpose__2
+ :: SX -> IO SX
+transpose__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_transpose__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "transpose__3" c_transpose__3
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Transpose of a matrix.
+-}
+transpose__3
+ :: DMatrix -> IO DMatrix
+transpose__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_transpose__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "transpose__4" c_transpose__4
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Transpose of a matrix.
+-}
+transpose__4
+ :: IMatrix -> IO IMatrix
+transpose__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_transpose__4 errStrPtrP x0'
+ 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 function
+>
+>\\\\[ \\\\begin {cases} \\\\Lambda(x) = 0 & |x| >= 1 \\\\\\\\ \\\\Lambda(x)
+>= 1-|x| & |x| < 1 \\\\end {cases} \\\\]
+-}
+triangle
+ :: SX -> IO SX
+triangle x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triangle errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril__0" c_tril__0
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+{-|
+>Get lower triangular part.
+-}
+tril__0
+ :: Sparsity -> IO Sparsity
+tril__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril__1" c_tril__1
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+{-|
+>Get lower triangular part.
+-}
+tril__1
+ :: Sparsity -> Bool -> IO Sparsity
+tril__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "tril__2" c_tril__2
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Get the lower triangular part of a matrix.
+-}
+tril__2
+ :: MX -> IO MX
+tril__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril__3" c_tril__3
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Get the lower triangular part of a matrix.
+-}
+tril__3
+ :: SX -> IO SX
+tril__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril__4" c_tril__4
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Get the lower triangular part of a matrix.
+-}
+tril__4
+ :: DMatrix -> IO DMatrix
+tril__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril__5" c_tril__5
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Get the lower triangular part of a matrix.
+-}
+tril__5
+ :: IMatrix -> IO IMatrix
+tril__5 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril__5 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril2symm__0" c_tril2symm__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Convert a lower triangular matrix to a symmetric one.
+-}
+tril2symm__0
+ :: MX -> IO MX
+tril2symm__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril2symm__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril2symm__1" c_tril2symm__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Convert a lower triangular matrix to a symmetric one.
+-}
+tril2symm__1
+ :: SX -> IO SX
+tril2symm__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril2symm__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril2symm__2" c_tril2symm__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Convert a lower triangular matrix to a symmetric one.
+-}
+tril2symm__2
+ :: DMatrix -> IO DMatrix
+tril2symm__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril2symm__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "tril2symm__3" c_tril2symm__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Convert a lower triangular matrix to a symmetric one.
+-}
+tril2symm__3
+ :: IMatrix -> IO IMatrix
+tril2symm__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_tril2symm__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu__0" c_triu__0
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+{-|
+>Get upper triangular part.
+-}
+triu__0
+ :: Sparsity -> IO Sparsity
+triu__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu__1" c_triu__1
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> CInt -> IO (Ptr Sparsity')
+{-|
+>Get upper triangular part.
+-}
+triu__1
+ :: Sparsity -> Bool -> IO Sparsity
+triu__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "triu__2" c_triu__2
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Get the upper triangular part of a matrix.
+-}
+triu__2
+ :: MX -> IO MX
+triu__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu__3" c_triu__3
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Get the upper triangular part of a matrix.
+-}
+triu__3
+ :: SX -> IO SX
+triu__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu__4" c_triu__4
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Get the upper triangular part of a matrix.
+-}
+triu__4
+ :: DMatrix -> IO DMatrix
+triu__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu__5" c_triu__5
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Get the upper triangular part of a matrix.
+-}
+triu__5
+ :: IMatrix -> IO IMatrix
+triu__5 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu__5 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu2symm__0" c_triu2symm__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Convert a upper triangular matrix to a symmetric one.
+-}
+triu2symm__0
+ :: MX -> IO MX
+triu2symm__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu2symm__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu2symm__1" c_triu2symm__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Convert a upper triangular matrix to a symmetric one.
+-}
+triu2symm__1
+ :: SX -> IO SX
+triu2symm__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu2symm__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu2symm__2" c_triu2symm__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Convert a upper triangular matrix to a symmetric one.
+-}
+triu2symm__2
+ :: DMatrix -> IO DMatrix
+triu2symm__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu2symm__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "triu2symm__3" c_triu2symm__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Convert a upper triangular matrix to a symmetric one.
+-}
+triu2symm__3
+ :: IMatrix -> IO IMatrix
+triu2symm__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_triu2symm__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "unite__0" c_unite__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Unite two matrices no overlapping sparsity.
+-}
+unite__0
+ :: MX -> MX -> IO MX
+unite__0 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "unite__1" c_unite__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Unite two matrices no overlapping sparsity.
+-}
+unite__1
+ :: SX -> SX -> IO SX
+unite__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "unite__2" c_unite__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Unite two matrices no overlapping sparsity.
+-}
+unite__2
+ :: DMatrix -> DMatrix -> IO DMatrix
+unite__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "unite__3" c_unite__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Unite two matrices no overlapping sparsity.
+-}
+unite__3
+ :: IMatrix -> IMatrix -> IO IMatrix
+unite__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "vec__0" c_vec__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Returns a vectorized version of the MX Same as reshape(x, x.numel(), 1)
+>
+>a c b d
+>
+>turns into
+>
+>a b c d
+-}
+vec__0
+ :: MX -> IO MX
+vec__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vec__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vec__1" c_vec__1
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> IO (Ptr Sparsity')
+{-|
+>Vectorize the pattern.
+-}
+vec__1
+ :: Sparsity -> IO Sparsity
+vec__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vec__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vec__2" c_vec__2
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>make a vector Reshapes/vectorizes the Matrix such that the shape
+>becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
+>reshape(expr, expr.numel(), 1)
+>
+>a c b d turns into
+>
+>a b c d
+-}
+vec__2
+ :: SX -> IO SX
+vec__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vec__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vec__3" c_vec__3
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>make a vector Reshapes/vectorizes the Matrix such that the shape
+>becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
+>reshape(expr, expr.numel(), 1)
+>
+>a c b d turns into
+>
+>a b c d
+-}
+vec__3
+ :: DMatrix -> IO DMatrix
+vec__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vec__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vec__4" c_vec__4
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>make a vector Reshapes/vectorizes the Matrix such that the shape
+>becomes (expr.numel(), 1). Columns are stacked on top of each other. Same as
+>reshape(expr, expr.numel(), 1)
+>
+>a c b d turns into
+>
+>a b c d
+-}
+vec__4
+ :: IMatrix -> IO IMatrix
+vec__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vec__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZ__0" c_vecNZ__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr MX')
+{-|
+>Returns a vectorized version of the MX, preserving only nonzeros.
+-}
+vecNZ__0
+ :: MX -> IO MX
+vecNZ__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZ__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZ__1" c_vecNZ__1
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')
+{-|
+>Returns a flattened version of the Matrix, preserving only nonzeros.
+-}
+vecNZ__1
+ :: SX -> IO SX
+vecNZ__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZ__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZ__2" c_vecNZ__2
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')
+{-|
+>Returns a flattened version of the Matrix, preserving only nonzeros.
+-}
+vecNZ__2
+ :: DMatrix -> IO DMatrix
+vecNZ__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZ__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZ__3" c_vecNZ__3
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')
+{-|
+>Returns a flattened version of the Matrix, preserving only nonzeros.
+-}
+vecNZ__3
+ :: IMatrix -> IO IMatrix
+vecNZ__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZ__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZcat__0" c_vecNZcat__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+{-|
+>concatenate vertically while vecing all arguments with vecNZ
+-}
+vecNZcat__0
+ :: Vector MX -> IO MX
+vecNZcat__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZcat__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZcat__1" c_vecNZcat__1
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+{-|
+>concatenate vertically while vectorizing all arguments with vecNZ
+-}
+vecNZcat__1
+ :: Vector SX -> IO SX
+vecNZcat__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZcat__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZcat__2" c_vecNZcat__2
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
+{-|
+>concatenate vertically while vectorizing all arguments with vecNZ
+-}
+vecNZcat__2
+ :: Vector DMatrix -> IO DMatrix
+vecNZcat__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZcat__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vecNZcat__3" c_vecNZcat__3
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
+{-|
+>concatenate vertically while vectorizing all arguments with vecNZ
+-}
+vecNZcat__3
+ :: Vector IMatrix -> IO IMatrix
+vecNZcat__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vecNZcat__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "veccat__0" c_veccat__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+{-|
+>Concatenate vertically while vectorizing all arguments.
+-}
+veccat__0
+ :: Vector MX -> IO MX
+veccat__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_veccat__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "veccat__1" c_veccat__1
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+{-|
+>concatenate vertically while vectorizing all arguments with vec
+-}
+veccat__1
+ :: Vector SX -> IO SX
+veccat__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_veccat__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "veccat__2" c_veccat__2
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
+{-|
+>concatenate vertically while vectorizing all arguments with vec
+-}
+veccat__2
+ :: Vector DMatrix -> IO DMatrix
+veccat__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_veccat__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "veccat__3" c_veccat__3
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
+{-|
+>concatenate vertically while vectorizing all arguments with vec
+-}
+veccat__3
+ :: Vector IMatrix -> IO IMatrix
+veccat__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_veccat__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertcat__0" c_vertcat__0
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr MX')) -> IO (Ptr MX')
+{-|
+>concatenate vertically
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertcat__0
+ :: Vector MX -> IO MX
+vertcat__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertcat__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertcat__1" c_vertcat__1
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr Sparsity')) -> IO (Ptr Sparsity')
+{-|
+>Concatenate a list of sparsities vertically Alternative terminology:
+>vertical stack, vstack, vertical append, [a;b].
+-}
+vertcat__1
+ :: Vector Sparsity -> IO Sparsity
+vertcat__1 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertcat__1 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertcat__2" c_vertcat__2
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr SX')) -> IO (Ptr SX')
+{-|
+>Concatenate a list of matrices vertically Alternative terminology: vertical
+>stack, vstack, vertical append, [a;b].
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertcat__2
+ :: Vector SX -> IO SX
+vertcat__2 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertcat__2 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertcat__3" c_vertcat__3
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr DMatrix')) -> IO (Ptr DMatrix')
+{-|
+>Concatenate a list of matrices vertically Alternative terminology: vertical
+>stack, vstack, vertical append, [a;b].
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertcat__3
+ :: Vector DMatrix -> IO DMatrix
+vertcat__3 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertcat__3 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertcat__4" c_vertcat__4
+ :: Ptr (Ptr StdString) -> Ptr (StdVec (Ptr IMatrix')) -> IO (Ptr IMatrix')
+{-|
+>Concatenate a list of matrices vertically Alternative terminology: vertical
+>stack, vstack, vertical append, [a;b].
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertcat__4
+ :: Vector IMatrix -> IO IMatrix
+vertcat__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertcat__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__0" c_vertsplit__0
+ :: Ptr (Ptr StdString) -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__0
+ :: MX -> IO (Vector MX)
+vertsplit__0 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertsplit__0 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__1" c_vertsplit__1
+ :: Ptr (Ptr StdString) -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__1
+ :: MX -> Int -> IO (Vector MX)
+vertsplit__1 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "vertsplit__2" c_vertsplit__2
+ :: Ptr (Ptr StdString) -> Ptr MX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr MX')))
+{-|
+>split vertically, retaining groups of rows
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start rows for each group the last row group
+>will run to the end.
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__2
+ :: MX -> Vector Int -> IO (Vector MX)
+vertsplit__2 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "vertsplit__3" c_vertsplit__3
+ :: Ptr (Ptr StdString) -> Ptr Sparsity' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr Sparsity')))
+{-|
+>Split up a sparsity pattern vertically.
+-}
+vertsplit__3
+ :: Sparsity -> Vector Int -> IO (Vector Sparsity)
+vertsplit__3 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertsplit__3 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__4" c_vertsplit__4
+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__4
+ :: SX -> IO (Vector SX)
+vertsplit__4 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertsplit__4 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__5" c_vertsplit__5
+ :: Ptr (Ptr StdString) -> Ptr SX' -> CInt -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__5
+ :: SX -> Int -> IO (Vector SX)
+vertsplit__5 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "vertsplit__6" c_vertsplit__6
+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr SX')))
+{-|
+>split vertically, retaining groups of rows
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start rows for each group the last row group
+>will run to the end.
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__6
+ :: SX -> Vector Int -> IO (Vector SX)
+vertsplit__6 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertsplit__6 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__7" c_vertsplit__7
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__7
+ :: DMatrix -> IO (Vector DMatrix)
+vertsplit__7 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertsplit__7 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__8" c_vertsplit__8
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> CInt -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__8
+ :: DMatrix -> Int -> IO (Vector DMatrix)
+vertsplit__8 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "vertsplit__9" c_vertsplit__9
+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr DMatrix')))
+{-|
+>split vertically, retaining groups of rows
+>
+>Parameters:
+>-----------
+>
+>output_offset: List of all start rows for each group the last row group
+>will run to the end.
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__9
+ :: DMatrix -> Vector Int -> IO (Vector DMatrix)
+vertsplit__9 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertsplit__9 errStrPtrP x0' x1'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__10" c_vertsplit__10
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__10
+ :: IMatrix -> IO (Vector IMatrix)
+vertsplit__10 x0 =
+ withMarshal x0 $ \x0' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_vertsplit__10 errStrPtrP x0'
+ errStrPtr <- peek errStrPtrP
+ free errStrPtrP
+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)
+
+
+foreign import ccall unsafe "vertsplit__11" c_vertsplit__11
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> CInt -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split vertically, retaining fixed-sized groups of rows
+>
+>Parameters:
+>-----------
+>
+>incr: Size of each group of rows
+>
+>vertcat(vertsplit(x, ...)) = x
+-}
+vertsplit__11
+ :: IMatrix -> Int -> IO (Vector IMatrix)
+vertsplit__11 x0 x1 =
+ withMarshal x0 $ \x0' ->
+ withMarshal x1 $ \x1' ->
+ do
+ errStrPtrP <- new nullPtr
+ ret <- c_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 "vertsplit__12" c_vertsplit__12
+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> Ptr (StdVec CInt) -> IO (Ptr (StdVec (Ptr IMatrix')))
+{-|
+>split vertically, retaining groups of rows
>
>Parameters:
>-----------
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.0.0.1
+version: 2.1.0.0
license: LGPL-3
license-file: LICENSE
category: Numerical, Math
@@ -28,7 +28,7 @@
ghc-prof-options: -prof -fprof-auto -fprof-cafs -rtsopts
ghc-options:
- cc-options: -Wall -Wno-delete-non-virtual-dtor
+ cc-options: -Wall -Wno-sign-compare
C-sources: cbits/autogen/core_classes.cpp
cbits/autogen/core_functions.cpp
@@ -39,11 +39,14 @@
Casadi.Core.Classes.Callback
Casadi.Core.Classes.CasadiMeta
Casadi.Core.Classes.CasadiOptions
+ Casadi.Core.Classes.CleSolver
Casadi.Core.Classes.ControlSimulator
Casadi.Core.Classes.CustomEvaluate
Casadi.Core.Classes.CustomFunction
Casadi.Core.Classes.DMatrix
Casadi.Core.Classes.DerivativeGenerator
+ Casadi.Core.Classes.DleSolver
+ Casadi.Core.Classes.DpleSolver
Casadi.Core.Classes.ExternalFunction
Casadi.Core.Classes.Function
Casadi.Core.Classes.Functor
@@ -55,14 +58,14 @@
Casadi.Core.Classes.Integrator
Casadi.Core.Classes.LinearSolver
Casadi.Core.Classes.LpSolver
+ Casadi.Core.Classes.LrDleSolver
+ Casadi.Core.Classes.LrDpleSolver
Casadi.Core.Classes.MX
Casadi.Core.Classes.MXFunction
Casadi.Core.Classes.NlpSolver
Casadi.Core.Classes.Nullspace
- Casadi.Core.Classes.OCPSolver
Casadi.Core.Classes.OptionsFunctionality
Casadi.Core.Classes.Parallelizer
- Casadi.Core.Classes.PrintableObject
Casadi.Core.Classes.QcqpSolver
Casadi.Core.Classes.QpSolver
Casadi.Core.Classes.SX
@@ -77,4 +80,7 @@
Casadi.Core.Classes.Sparsity
Casadi.Core.Classes.StabilizedQpSolver
Casadi.Core.Classes.SymbolicNLP
+ Casadi.Core.Classes.SymbolicOCP
+ Casadi.Core.Classes.Variable
+ Casadi.Core.Classes.XmlFile
Casadi.Core.Classes.IOInterfaceFunction
diff --git a/cbits/autogen/core_classes.cpp b/cbits/autogen/core_classes.cpp
# file too large to diff: cbits/autogen/core_classes.cpp
diff --git a/cbits/autogen/core_functions.cpp b/cbits/autogen/core_functions.cpp
# file too large to diff: cbits/autogen/core_functions.cpp