casadi-bindings-core 2.0.0.1 → 2.1.0.0
raw patch · 53 files changed
+43587/−33299 lines, 53 files
Files
- Casadi/Core/Classes/Callback.hs +0/−3
- Casadi/Core/Classes/CasadiOptions.hs +14/−14
- Casadi/Core/Classes/CleSolver.hs +136/−0
- Casadi/Core/Classes/ControlSimulator.hs +0/−3
- Casadi/Core/Classes/CustomEvaluate.hs +0/−3
- Casadi/Core/Classes/CustomFunction.hs +0/−3
- Casadi/Core/Classes/DMatrix.hs +32/−11
- Casadi/Core/Classes/DerivativeGenerator.hs +0/−3
- Casadi/Core/Classes/DleSolver.hs +157/−0
- Casadi/Core/Classes/DpleSolver.hs +180/−0
- Casadi/Core/Classes/ExternalFunction.hs +0/−3
- Casadi/Core/Classes/Function.hs +23/−3
- Casadi/Core/Classes/Functor.hs +0/−4
- Casadi/Core/Classes/GenericType.hs +0/−3
- Casadi/Core/Classes/HomotopyNlpSolver.hs +0/−3
- Casadi/Core/Classes/IMatrix.hs +32/−11
- Casadi/Core/Classes/IOScheme.hs +0/−3
- Casadi/Core/Classes/ImplicitFunction.hs +0/−3
- Casadi/Core/Classes/Integrator.hs +0/−3
- Casadi/Core/Classes/LinearSolver.hs +0/−3
- Casadi/Core/Classes/LpSolver.hs +0/−3
- Casadi/Core/Classes/LrDleSolver.hs +157/−0
- Casadi/Core/Classes/LrDpleSolver.hs +157/−0
- Casadi/Core/Classes/MX.hs +0/−3
- Casadi/Core/Classes/MXFunction.hs +0/−3
- Casadi/Core/Classes/NlpSolver.hs +21/−3
- Casadi/Core/Classes/Nullspace.hs +0/−3
- Casadi/Core/Classes/OCPSolver.hs +0/−139
- Casadi/Core/Classes/OptionsFunctionality.hs +0/−3
- Casadi/Core/Classes/Parallelizer.hs +0/−3
- Casadi/Core/Classes/PrintableObject.hs +0/−75
- Casadi/Core/Classes/QcqpSolver.hs +21/−3
- Casadi/Core/Classes/QpSolver.hs +21/−3
- Casadi/Core/Classes/SX.hs +32/−11
- Casadi/Core/Classes/SXFunction.hs +0/−3
- Casadi/Core/Classes/SdpSolver.hs +21/−3
- Casadi/Core/Classes/SdqpSolver.hs +0/−3
- Casadi/Core/Classes/SharedObject.hs +0/−24
- Casadi/Core/Classes/Simulator.hs +0/−3
- Casadi/Core/Classes/Slice.hs +0/−3
- Casadi/Core/Classes/SocpSolver.hs +21/−3
- Casadi/Core/Classes/Sparsity.hs +64/−3
- Casadi/Core/Classes/StabilizedQpSolver.hs +0/−3
- Casadi/Core/Classes/SymbolicNLP.hs +0/−3
- Casadi/Core/Classes/SymbolicOCP.hs +1654/−0
- Casadi/Core/Classes/Variable.hs +185/−0
- Casadi/Core/Classes/XmlFile.hs +115/−0
- Casadi/Core/Data.hs +12674/−11102
- Casadi/Core/Enums.hs +590/−225
- Casadi/Core/Tools.hs +27270/−21586
- casadi-bindings-core.cabal +10/−4
- cbits/autogen/core_classes.cpp too large to diff
- cbits/autogen/core_functions.cpp too large to diff
Casadi/Core/Classes/Callback.hs view
@@ -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')
Casadi/Core/Classes/CasadiOptions.hs view
@@ -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
+ Casadi/Core/Classes/CleSolver.hs view
@@ -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)+
Casadi/Core/Classes/ControlSimulator.hs view
@@ -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')
Casadi/Core/Classes/CustomEvaluate.hs view
@@ -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')
Casadi/Core/Classes/CustomFunction.hs view
@@ -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')
Casadi/Core/Classes/DMatrix.hs view
@@ -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
Casadi/Core/Classes/DerivativeGenerator.hs view
@@ -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')
+ Casadi/Core/Classes/DleSolver.hs view
@@ -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)+
+ Casadi/Core/Classes/DpleSolver.hs view
@@ -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)+
Casadi/Core/Classes/ExternalFunction.hs view
@@ -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')
Casadi/Core/Classes/Function.hs view
@@ -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
Casadi/Core/Classes/Functor.hs view
@@ -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
Casadi/Core/Classes/GenericType.hs view
@@ -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')
Casadi/Core/Classes/HomotopyNlpSolver.hs view
@@ -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')
Casadi/Core/Classes/IMatrix.hs view
@@ -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
Casadi/Core/Classes/IOScheme.hs view
@@ -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')
Casadi/Core/Classes/ImplicitFunction.hs view
@@ -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')
Casadi/Core/Classes/Integrator.hs view
@@ -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')
Casadi/Core/Classes/LinearSolver.hs view
@@ -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')
Casadi/Core/Classes/LpSolver.hs view
@@ -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')
+ Casadi/Core/Classes/LrDleSolver.hs view
@@ -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)+
+ Casadi/Core/Classes/LrDpleSolver.hs view
@@ -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)+
Casadi/Core/Classes/MX.hs view
@@ -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')
Casadi/Core/Classes/MXFunction.hs view
@@ -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')
Casadi/Core/Classes/NlpSolver.hs view
@@ -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
Casadi/Core/Classes/Nullspace.hs view
@@ -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')
− Casadi/Core/Classes/OCPSolver.hs
@@ -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)-
Casadi/Core/Classes/OptionsFunctionality.hs view
@@ -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')
Casadi/Core/Classes/Parallelizer.hs view
@@ -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')
− Casadi/Core/Classes/PrintableObject.hs
@@ -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)-
Casadi/Core/Classes/QcqpSolver.hs view
@@ -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
Casadi/Core/Classes/QpSolver.hs view
@@ -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
Casadi/Core/Classes/SX.hs view
@@ -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
Casadi/Core/Classes/SXFunction.hs view
@@ -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')
Casadi/Core/Classes/SdpSolver.hs view
@@ -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
Casadi/Core/Classes/SdqpSolver.hs view
@@ -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')
@@ -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
Casadi/Core/Classes/Simulator.hs view
@@ -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')
Casadi/Core/Classes/Slice.hs view
@@ -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')
Casadi/Core/Classes/SocpSolver.hs view
@@ -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
Casadi/Core/Classes/Sparsity.hs view
@@ -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
Casadi/Core/Classes/StabilizedQpSolver.hs view
@@ -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')
Casadi/Core/Classes/SymbolicNLP.hs view
@@ -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 ()
+ Casadi/Core/Classes/SymbolicOCP.hs view
@@ -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)+
+ Casadi/Core/Classes/Variable.hs view
@@ -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)+
+ Casadi/Core/Classes/XmlFile.hs view
@@ -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+
Casadi/Core/Data.hs view
@@ -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->===============->->->->- <a href='#plugin_HomotopyNlpSolver_simple'>simple</a>->->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->===============->->->->- <a href='#plugin_ImplicitFunction_kinsol'>kinsol</a>->->- <a href='#plugin_ImplicitFunction_newton'>newton</a>->->- <a href='#plugin_ImplicitFunction_nlp'>nlp</a>->->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->===============->->->->- <a href='#plugin_Integrator_cvodes'>cvodes</a>->->- <a href='#plugin_Integrator_idas'>idas</a>->->- <a href='#plugin_Integrator_collocation'>collocation</a>->->- <a href='#plugin_Integrator_oldcollocation'>oldcollocation</a>->->- <a href='#plugin_Integrator_rk'>rk</a>->->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->===============->->->->- <a href='#plugin_LinearSolver_csparsecholesky'>csparsecholesky</a>->->- <a href='#plugin_LinearSolver_csparse'>csparse</a>->->- <a href='#plugin_LinearSolver_lapacklu'>lapacklu</a>->->- <a href='#plugin_LinearSolver_lapackqr'>lapackqr</a>->->- <a href='#plugin_LinearSolver_symbolicqr'>symbolicqr</a>->->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->===============->->->->- <a href='#plugin_LpSolver_qp'>qp</a>->->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->===============->->->->- <a href='#plugin_NlpSolver_ipopt'>ipopt</a>->->- <a href='#plugin_NlpSolver_knitro'>knitro</a>->->- <a href='#plugin_NlpSolver_snopt'>snopt</a>->->- <a href='#plugin_NlpSolver_worhp'>worhp</a>->->- <a href='#plugin_NlpSolver_scpgen'>scpgen</a>->->- <a href='#plugin_NlpSolver_sqpmethod'>sqpmethod</a>->->- <a href='#plugin_NlpSolver_stabilizedsqp'>stabilizedsqp</a>->->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->===============->->->->- <a href='#plugin_QcqpSolver_socp'>socp</a>->->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->===============->->->->- <a href='#plugin_QpSolver_cplex'>cplex</a>->->- <a href='#plugin_QpSolver_ooqp'>ooqp</a>->->- <a href='#plugin_QpSolver_qpoases'>qpoases</a>->->- <a href='#plugin_QpSolver_sqic'>sqic</a>->->- <a href='#plugin_QpSolver_nlp'>nlp</a>->->- <a href='#plugin_QpSolver_qcqp'>qcqp</a>->->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->===============->->->->- <a href='#plugin_SdpSolver_dsdp'>dsdp</a>->->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->===============->->->->- <a href='#plugin_SdqpSolver_sdp'>sdp</a>->->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<SXFunction>(base);->->A failed shared_cast will result in a null pointer (cf. dynamic_cast)->->Joel Andersson->->C++ includes: shared_object.hpp --}-newtype SharedObject = SharedObject (ForeignPtr SharedObject')--- typeclass decl-class SharedObjectClass a where- castSharedObject :: a -> SharedObject-instance SharedObjectClass SharedObject where- castSharedObject = id---- baseclass instances-instance PrintableObjectClass SharedObject where- castPrintableObject (SharedObject x) = PrintableObject (castForeignPtr x)----- helper instances-instance Marshal SharedObject (Ptr SharedObject') where- 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->===============->->->->- <a href='#plugin_SocpSolver_sdp'>sdp</a>->->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->===============->->->->- <a href='#plugin_StabilizedQpSolver_sqic'>sqic</a>->->- <a href='#plugin_StabilizedQpSolver_qp'>qp</a>->->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+>===============+>+>+>+>- <a href='#plugin_CleSolver_simple'>simple</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_DleSolver_dple'>dple</a>+>+>- <a href='#plugin_DleSolver_fixed_smith'>fixed_smith</a>+>+>- <a href='#plugin_DleSolver_lrdle'>lrdle</a>+>+>- <a href='#plugin_DleSolver_simple'>simple</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_DpleSolver_slicot'>slicot</a>+>+>- <a href='#plugin_DpleSolver_condensing'>condensing</a>+>+>- <a href='#plugin_DpleSolver_lifting'>lifting</a>+>+>- <a href='#plugin_DpleSolver_lrdple'>lrdple</a>+>+>- <a href='#plugin_DpleSolver_simple'>simple</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_HomotopyNlpSolver_simple'>simple</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_ImplicitFunction_kinsol'>kinsol</a>+>+>- <a href='#plugin_ImplicitFunction_nlp'>nlp</a>+>+>- <a href='#plugin_ImplicitFunction_newton'>newton</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_Integrator_cvodes'>cvodes</a>+>+>- <a href='#plugin_Integrator_idas'>idas</a>+>+>- <a href='#plugin_Integrator_collocation'>collocation</a>+>+>- <a href='#plugin_Integrator_oldcollocation'>oldcollocation</a>+>+>- <a href='#plugin_Integrator_rk'>rk</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_LinearSolver_csparsecholesky'>csparsecholesky</a>+>+>- <a href='#plugin_LinearSolver_csparse'>csparse</a>+>+>- <a href='#plugin_LinearSolver_lapacklu'>lapacklu</a>+>+>- <a href='#plugin_LinearSolver_lapackqr'>lapackqr</a>+>+>- <a href='#plugin_LinearSolver_symbolicqr'>symbolicqr</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_LpSolver_qp'>qp</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_LrDleSolver_dle'>dle</a>+>+>- <a href='#plugin_LrDleSolver_fixed_smith'>fixed_smith</a>+>+>- <a href='#plugin_LrDleSolver_smith'>smith</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_LrDpleSolver_dple'>dple</a>+>+>- <a href='#plugin_LrDpleSolver_lifting'>lifting</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_NlpSolver_ipopt'>ipopt</a>+>+>- <a href='#plugin_NlpSolver_knitro'>knitro</a>+>+>- <a href='#plugin_NlpSolver_snopt'>snopt</a>+>+>- <a href='#plugin_NlpSolver_worhp'>worhp</a>+>+>- <a href='#plugin_NlpSolver_scpgen'>scpgen</a>+>+>- <a href='#plugin_NlpSolver_sqpmethod'>sqpmethod</a>+>+>- <a href='#plugin_NlpSolver_stabilizedsqp'>stabilizedsqp</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_QcqpSolver_socp'>socp</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_QpSolver_cplex'>cplex</a>+>+>- <a href='#plugin_QpSolver_ooqp'>ooqp</a>+>+>- <a href='#plugin_QpSolver_qpoases'>qpoases</a>+>+>- <a href='#plugin_QpSolver_sqic'>sqic</a>+>+>- <a href='#plugin_QpSolver_nlp'>nlp</a>+>+>- <a href='#plugin_QpSolver_qcqp'>qcqp</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_SdpSolver_dsdp'>dsdp</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_SdqpSolver_sdp'>sdp</a>+>+>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<SXFunction>(base);+>+>A failed shared_cast will result in a null pointer (cf. dynamic_cast)+>+>Joel Andersson+>+>C++ includes: shared_object.hpp +-}+newtype SharedObject = SharedObject (ForeignPtr SharedObject')+-- typeclass decl+class SharedObjectClass a where+ castSharedObject :: a -> SharedObject+instance SharedObjectClass SharedObject where+ castSharedObject = id++-- baseclass instances++-- 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+>===============+>+>+>+>- <a href='#plugin_SocpSolver_sdp'>sdp</a>+>+>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+>===============+>+>+>+>- <a href='#plugin_StabilizedQpSolver_sqic'>sqic</a>+>+>- <a href='#plugin_StabilizedQpSolver_qp'>qp</a>+>+>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
Casadi/Core/Enums.hs view
@@ -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
Casadi/Core/Tools.hs view
@@ -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<int> mapping; Sparsity sp = A.sparsity().patternIntersection(sp,->mapping);->->Split up the mapping std::vector<int> nzA, nzB;->->Copy sparsity for (int k=0; k<mapping.size(); ++k) { if (mapping[k]<0) {->nzA.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<size1), mul(pinv(A), A) is unity.--}-pinv__0- :: MX -> String -> IO MX-pinv__0 x0 x1 =- withMarshal x0 $ \x0' ->- withMarshal x1 $ \x1' ->- do- errStrPtrP <- new nullPtr- ret <- c_pinv__0 errStrPtrP x0' x1'- errStrPtr <- peek errStrPtrP- free errStrPtrP- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)---foreign import ccall unsafe "pinv__1" c_pinv__1- :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')-{-|->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<size2), mul(pinv(A), A) is unity.--}-pinv__1- :: SX -> IO SX-pinv__1 x0 =- withMarshal x0 $ \x0' ->- do- errStrPtrP <- new nullPtr- ret <- c_pinv__1 errStrPtrP x0'- errStrPtr <- peek errStrPtrP- free errStrPtrP- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)---foreign import ccall unsafe "pinv__2" c_pinv__2- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')-{-|->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<size2), mul(pinv(A), A) is unity.--}-pinv__2- :: DMatrix -> IO DMatrix-pinv__2 x0 =- withMarshal x0 $ \x0' ->- do- errStrPtrP <- new nullPtr- ret <- c_pinv__2 errStrPtrP x0'- errStrPtr <- peek errStrPtrP- free errStrPtrP- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)---foreign import ccall unsafe "pinv__3" c_pinv__3- :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')-{-|->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<size2), mul(pinv(A), A) is unity.--}-pinv__3- :: IMatrix -> IO IMatrix-pinv__3 x0 =- withMarshal x0 $ \x0' ->- do- errStrPtrP <- new nullPtr- ret <- c_pinv__3 errStrPtrP x0'- errStrPtr <- peek errStrPtrP- free errStrPtrP- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)---foreign import ccall unsafe "pinv__4" c_pinv__4- :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')-{-|->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<size1), mul(pinv(A), A) is unity.--}-pinv__4- :: DMatrix -> String -> IO DMatrix-pinv__4 x0 x1 =- withMarshal x0 $ \x0' ->- withMarshal x1 $ \x1' ->- do- errStrPtrP <- new nullPtr- ret <- c_pinv__4 errStrPtrP x0' x1'- errStrPtr <- peek errStrPtrP- free errStrPtrP- if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)---foreign import ccall unsafe "poly_coeff" c_poly_coeff- :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')-{-|->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<DataType> 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<DataType> 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<DataType> 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<int> mapping; Sparsity sp = A.sparsity().patternIntersection(sp,+>mapping);+>+>Split up the mapping std::vector<int> nzA, nzB;+>+>Copy sparsity for (int k=0; k<mapping.size(); ++k) { if (mapping[k]<0) {+>nzA.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<size1), mul(pinv(A), A) is unity.+-}+pinv__0+ :: MX -> String -> IO MX+pinv__0 x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ do+ errStrPtrP <- new nullPtr+ ret <- c_pinv__0 errStrPtrP x0' x1'+ errStrPtr <- peek errStrPtrP+ free errStrPtrP+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)+++foreign import ccall unsafe "pinv__1" c_pinv__1+ :: Ptr (Ptr StdString) -> Ptr SX' -> IO (Ptr SX')+{-|+>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<size2), mul(pinv(A), A) is unity.+-}+pinv__1+ :: SX -> IO SX+pinv__1 x0 =+ withMarshal x0 $ \x0' ->+ do+ errStrPtrP <- new nullPtr+ ret <- c_pinv__1 errStrPtrP x0'+ errStrPtr <- peek errStrPtrP+ free errStrPtrP+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)+++foreign import ccall unsafe "pinv__2" c_pinv__2+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> IO (Ptr DMatrix')+{-|+>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<size2), mul(pinv(A), A) is unity.+-}+pinv__2+ :: DMatrix -> IO DMatrix+pinv__2 x0 =+ withMarshal x0 $ \x0' ->+ do+ errStrPtrP <- new nullPtr+ ret <- c_pinv__2 errStrPtrP x0'+ errStrPtr <- peek errStrPtrP+ free errStrPtrP+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)+++foreign import ccall unsafe "pinv__3" c_pinv__3+ :: Ptr (Ptr StdString) -> Ptr IMatrix' -> IO (Ptr IMatrix')+{-|+>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<size2), mul(pinv(A), A) is unity.+-}+pinv__3+ :: IMatrix -> IO IMatrix+pinv__3 x0 =+ withMarshal x0 $ \x0' ->+ do+ errStrPtrP <- new nullPtr+ ret <- c_pinv__3 errStrPtrP x0'+ errStrPtr <- peek errStrPtrP+ free errStrPtrP+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)+++foreign import ccall unsafe "pinv__4" c_pinv__4+ :: Ptr (Ptr StdString) -> Ptr DMatrix' -> Ptr StdString -> IO (Ptr DMatrix')+{-|+>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<size1), mul(pinv(A), A) is unity.+-}+pinv__4+ :: DMatrix -> String -> IO DMatrix+pinv__4 x0 x1 =+ withMarshal x0 $ \x0' ->+ withMarshal x1 $ \x1' ->+ do+ errStrPtrP <- new nullPtr+ ret <- c_pinv__4 errStrPtrP x0' x1'+ errStrPtr <- peek errStrPtrP+ free errStrPtrP+ if errStrPtr == nullPtr then wrapReturn ret else wrapReturn errStrPtr >>= (error . formatException)+++foreign import ccall unsafe "poly_coeff" c_poly_coeff+ :: Ptr (Ptr StdString) -> Ptr SX' -> Ptr SX' -> IO (Ptr SX')+{-|+>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<DataType> 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<DataType> 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<DataType> 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: >-----------
casadi-bindings-core.cabal view
@@ -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
cbits/autogen/core_classes.cpp view
file too large to diff
cbits/autogen/core_functions.cpp view
file too large to diff