{-# OPTIONS_GHC -Wall #-} {-# OPTIONS_GHC -fno-warn-unused-imports #-} {-# OPTIONS_GHC -fno-warn-orphans #-} {-# Language ForeignFunctionInterface #-} {-# Language FlexibleInstances #-} {-# Language MultiParamTypeClasses #-} module Casadi.Core.Classes.OptiAdvanced ( OptiAdvanced, OptiAdvancedClass(..), optiAdvanced, optiAdvanced_active_symvar, optiAdvanced_active_values, optiAdvanced_arg, optiAdvanced_assert_active_symbol, optiAdvanced_assert_baked, optiAdvanced_assert_empty, optiAdvanced_assert_solved, optiAdvanced_bake, optiAdvanced_baked_copy, optiAdvanced_canon_expr, optiAdvanced_casadi_solver, optiAdvanced_constraints, optiAdvanced_describe__0, optiAdvanced_describe__1, optiAdvanced_g_describe, optiAdvanced_g_lookup, optiAdvanced_get_meta, optiAdvanced_get_meta_con, optiAdvanced_instance_number, optiAdvanced_is_parametric, optiAdvanced_mark_problem_dirty__0, optiAdvanced_mark_problem_dirty__1, optiAdvanced_mark_solved__0, optiAdvanced_mark_solved__1, optiAdvanced_mark_solver_dirty__0, optiAdvanced_mark_solver_dirty__1, optiAdvanced_objective, optiAdvanced_problem_dirty, optiAdvanced_res__0, optiAdvanced_res__1, optiAdvanced_set_meta, optiAdvanced_set_meta_con, optiAdvanced_show_infeasibilities__0, optiAdvanced_show_infeasibilities__1, optiAdvanced_solve_actual, optiAdvanced_solve_prepare, optiAdvanced_solved, optiAdvanced_solver_dirty, optiAdvanced_symvar__0, optiAdvanced_symvar__1, optiAdvanced_symvar__2, optiAdvanced_x_describe, optiAdvanced_x_lookup, ) where import Prelude hiding ( Functor ) import Data.Vector ( Vector ) import qualified Data.Map as M import Foreign.C.Types import Foreign.Marshal ( new, free ) import Foreign.Storable ( peek ) import Foreign.Ptr ( Ptr, nullPtr ) import Foreign.ForeignPtr ( newForeignPtr ) import System.IO.Unsafe ( unsafePerformIO ) -- for show instances import Casadi.Internal.FormatException ( formatException ) import Casadi.Internal.MarshalTypes ( StdVec, StdString, StdMap, StdPair ) -- StdPair StdOstream' import Casadi.Internal.Marshal ( Marshal(..), marshal, marshalFree ) import Casadi.Internal.WrapReturn ( WrapReturn(..) ) import Casadi.Core.Data import Casadi.Core.Enums -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__CONSTRUCTOR" c_casadi__OptiAdvanced__CONSTRUCTOR :: Ptr (Ptr StdString) -> Ptr Opti' -> IO (Ptr OptiAdvanced') casadi__OptiAdvanced__CONSTRUCTOR :: Opti -> IO OptiAdvanced casadi__OptiAdvanced__CONSTRUCTOR x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__CONSTRUCTOR errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced :: Opti -> IO OptiAdvanced optiAdvanced = casadi__OptiAdvanced__CONSTRUCTOR -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__active_symvar" c_casadi__OptiAdvanced__active_symvar :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) casadi__OptiAdvanced__active_symvar :: OptiAdvanced -> VariableType -> IO (Vector MX) casadi__OptiAdvanced__active_symvar x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__active_symvar errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_active_symvar :: OptiAdvancedClass a => a -> VariableType -> IO (Vector MX) optiAdvanced_active_symvar x = casadi__OptiAdvanced__active_symvar (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__active_values" c_casadi__OptiAdvanced__active_values :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CInt -> IO (Ptr (StdVec (Ptr DM'))) casadi__OptiAdvanced__active_values :: OptiAdvanced -> VariableType -> IO (Vector DM) casadi__OptiAdvanced__active_values x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__active_values errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_active_values :: OptiAdvancedClass a => a -> VariableType -> IO (Vector DM) optiAdvanced_active_values x = casadi__OptiAdvanced__active_values (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__arg" c_casadi__OptiAdvanced__arg :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO (Ptr (StdMap StdString (Ptr DM'))) casadi__OptiAdvanced__arg :: OptiAdvanced -> IO (M.Map String DM) casadi__OptiAdvanced__arg x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__arg errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_arg :: OptiAdvancedClass a => a -> IO (M.Map String DM) optiAdvanced_arg x = casadi__OptiAdvanced__arg (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__assert_active_symbol" c_casadi__OptiAdvanced__assert_active_symbol :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> IO () casadi__OptiAdvanced__assert_active_symbol :: OptiAdvanced -> MX -> IO () casadi__OptiAdvanced__assert_active_symbol x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__assert_active_symbol errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return () -- classy wrapper optiAdvanced_assert_active_symbol :: OptiAdvancedClass a => a -> MX -> IO () optiAdvanced_assert_active_symbol x = casadi__OptiAdvanced__assert_active_symbol (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__assert_baked" c_casadi__OptiAdvanced__assert_baked :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__assert_baked :: OptiAdvanced -> IO () casadi__OptiAdvanced__assert_baked x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__assert_baked errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_assert_baked :: OptiAdvancedClass a => a -> IO () optiAdvanced_assert_baked x = casadi__OptiAdvanced__assert_baked (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__assert_empty" c_casadi__OptiAdvanced__assert_empty :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__assert_empty :: OptiAdvanced -> IO () casadi__OptiAdvanced__assert_empty x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__assert_empty errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_assert_empty :: OptiAdvancedClass a => a -> IO () optiAdvanced_assert_empty x = casadi__OptiAdvanced__assert_empty (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__assert_solved" c_casadi__OptiAdvanced__assert_solved :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__assert_solved :: OptiAdvanced -> IO () casadi__OptiAdvanced__assert_solved x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__assert_solved errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_assert_solved :: OptiAdvancedClass a => a -> IO () optiAdvanced_assert_solved x = casadi__OptiAdvanced__assert_solved (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__bake" c_casadi__OptiAdvanced__bake :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__bake :: OptiAdvanced -> IO () casadi__OptiAdvanced__bake x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__bake errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_bake :: OptiAdvancedClass a => a -> IO () optiAdvanced_bake x = casadi__OptiAdvanced__bake (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__baked_copy" c_casadi__OptiAdvanced__baked_copy :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO (Ptr OptiAdvanced') casadi__OptiAdvanced__baked_copy :: OptiAdvanced -> IO OptiAdvanced casadi__OptiAdvanced__baked_copy x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__baked_copy errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_baked_copy :: OptiAdvancedClass a => a -> IO OptiAdvanced optiAdvanced_baked_copy x = casadi__OptiAdvanced__baked_copy (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__canon_expr" c_casadi__OptiAdvanced__canon_expr :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> IO (Ptr MetaCon') casadi__OptiAdvanced__canon_expr :: OptiAdvanced -> MX -> IO MetaCon casadi__OptiAdvanced__canon_expr x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__canon_expr errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_canon_expr :: OptiAdvancedClass a => a -> MX -> IO MetaCon optiAdvanced_canon_expr x = casadi__OptiAdvanced__canon_expr (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__casadi_solver" c_casadi__OptiAdvanced__casadi_solver :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO (Ptr Function') casadi__OptiAdvanced__casadi_solver :: OptiAdvanced -> IO Function casadi__OptiAdvanced__casadi_solver x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__casadi_solver errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_casadi_solver :: OptiAdvancedClass a => a -> IO Function optiAdvanced_casadi_solver x = casadi__OptiAdvanced__casadi_solver (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__constraints" c_casadi__OptiAdvanced__constraints :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO (Ptr (StdVec (Ptr MX'))) casadi__OptiAdvanced__constraints :: OptiAdvanced -> IO (Vector MX) casadi__OptiAdvanced__constraints x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__constraints errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_constraints :: OptiAdvancedClass a => a -> IO (Vector MX) optiAdvanced_constraints x = casadi__OptiAdvanced__constraints (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__describe__0" c_casadi__OptiAdvanced__describe__0 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> IO (Ptr StdString) casadi__OptiAdvanced__describe__0 :: OptiAdvanced -> MX -> IO String casadi__OptiAdvanced__describe__0 x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__describe__0 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_describe__0 :: OptiAdvancedClass a => a -> MX -> IO String optiAdvanced_describe__0 x = casadi__OptiAdvanced__describe__0 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__describe__1" c_casadi__OptiAdvanced__describe__1 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> CLLong -> IO (Ptr StdString) casadi__OptiAdvanced__describe__1 :: OptiAdvanced -> MX -> Int -> IO String casadi__OptiAdvanced__describe__1 x0 x1 x2 = do x0' <- marshal x0 x1' <- marshal x1 x2' <- marshal x2 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__describe__1 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' marshalFree x2 x2' return ret -- classy wrapper optiAdvanced_describe__1 :: OptiAdvancedClass a => a -> MX -> Int -> IO String optiAdvanced_describe__1 x = casadi__OptiAdvanced__describe__1 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__g_describe" c_casadi__OptiAdvanced__g_describe :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CLLong -> IO (Ptr StdString) casadi__OptiAdvanced__g_describe :: OptiAdvanced -> Int -> IO String casadi__OptiAdvanced__g_describe x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__g_describe errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_g_describe :: OptiAdvancedClass a => a -> Int -> IO String optiAdvanced_g_describe x = casadi__OptiAdvanced__g_describe (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__g_lookup" c_casadi__OptiAdvanced__g_lookup :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CLLong -> IO (Ptr MX') casadi__OptiAdvanced__g_lookup :: OptiAdvanced -> Int -> IO MX casadi__OptiAdvanced__g_lookup x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__g_lookup errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_g_lookup :: OptiAdvancedClass a => a -> Int -> IO MX optiAdvanced_g_lookup x = casadi__OptiAdvanced__g_lookup (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__get_meta" c_casadi__OptiAdvanced__get_meta :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> IO (Ptr MetaVar') casadi__OptiAdvanced__get_meta :: OptiAdvanced -> MX -> IO MetaVar casadi__OptiAdvanced__get_meta x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__get_meta errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_get_meta :: OptiAdvancedClass a => a -> MX -> IO MetaVar optiAdvanced_get_meta x = casadi__OptiAdvanced__get_meta (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__get_meta_con" c_casadi__OptiAdvanced__get_meta_con :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> IO (Ptr MetaCon') casadi__OptiAdvanced__get_meta_con :: OptiAdvanced -> MX -> IO MetaCon casadi__OptiAdvanced__get_meta_con x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__get_meta_con errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_get_meta_con :: OptiAdvancedClass a => a -> MX -> IO MetaCon optiAdvanced_get_meta_con x = casadi__OptiAdvanced__get_meta_con (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__instance_number" c_casadi__OptiAdvanced__instance_number :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO CLLong casadi__OptiAdvanced__instance_number :: OptiAdvanced -> IO Int casadi__OptiAdvanced__instance_number x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__instance_number errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_instance_number :: OptiAdvancedClass a => a -> IO Int optiAdvanced_instance_number x = casadi__OptiAdvanced__instance_number (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__is_parametric" c_casadi__OptiAdvanced__is_parametric :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> IO CInt casadi__OptiAdvanced__is_parametric :: OptiAdvanced -> MX -> IO Bool casadi__OptiAdvanced__is_parametric x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__is_parametric errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_is_parametric :: OptiAdvancedClass a => a -> MX -> IO Bool optiAdvanced_is_parametric x = casadi__OptiAdvanced__is_parametric (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__mark_problem_dirty__0" c_casadi__OptiAdvanced__mark_problem_dirty__0 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__mark_problem_dirty__0 :: OptiAdvanced -> IO () casadi__OptiAdvanced__mark_problem_dirty__0 x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__mark_problem_dirty__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_mark_problem_dirty__0 :: OptiAdvancedClass a => a -> IO () optiAdvanced_mark_problem_dirty__0 x = casadi__OptiAdvanced__mark_problem_dirty__0 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__mark_problem_dirty__1" c_casadi__OptiAdvanced__mark_problem_dirty__1 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CInt -> IO () casadi__OptiAdvanced__mark_problem_dirty__1 :: OptiAdvanced -> Bool -> IO () casadi__OptiAdvanced__mark_problem_dirty__1 x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__mark_problem_dirty__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return () -- classy wrapper optiAdvanced_mark_problem_dirty__1 :: OptiAdvancedClass a => a -> Bool -> IO () optiAdvanced_mark_problem_dirty__1 x = casadi__OptiAdvanced__mark_problem_dirty__1 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__mark_solved__0" c_casadi__OptiAdvanced__mark_solved__0 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__mark_solved__0 :: OptiAdvanced -> IO () casadi__OptiAdvanced__mark_solved__0 x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__mark_solved__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_mark_solved__0 :: OptiAdvancedClass a => a -> IO () optiAdvanced_mark_solved__0 x = casadi__OptiAdvanced__mark_solved__0 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__mark_solved__1" c_casadi__OptiAdvanced__mark_solved__1 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CInt -> IO () casadi__OptiAdvanced__mark_solved__1 :: OptiAdvanced -> Bool -> IO () casadi__OptiAdvanced__mark_solved__1 x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__mark_solved__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return () -- classy wrapper optiAdvanced_mark_solved__1 :: OptiAdvancedClass a => a -> Bool -> IO () optiAdvanced_mark_solved__1 x = casadi__OptiAdvanced__mark_solved__1 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__mark_solver_dirty__0" c_casadi__OptiAdvanced__mark_solver_dirty__0 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__mark_solver_dirty__0 :: OptiAdvanced -> IO () casadi__OptiAdvanced__mark_solver_dirty__0 x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__mark_solver_dirty__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_mark_solver_dirty__0 :: OptiAdvancedClass a => a -> IO () optiAdvanced_mark_solver_dirty__0 x = casadi__OptiAdvanced__mark_solver_dirty__0 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__mark_solver_dirty__1" c_casadi__OptiAdvanced__mark_solver_dirty__1 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CInt -> IO () casadi__OptiAdvanced__mark_solver_dirty__1 :: OptiAdvanced -> Bool -> IO () casadi__OptiAdvanced__mark_solver_dirty__1 x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__mark_solver_dirty__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return () -- classy wrapper optiAdvanced_mark_solver_dirty__1 :: OptiAdvancedClass a => a -> Bool -> IO () optiAdvanced_mark_solver_dirty__1 x = casadi__OptiAdvanced__mark_solver_dirty__1 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__objective" c_casadi__OptiAdvanced__objective :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO (Ptr MX') casadi__OptiAdvanced__objective :: OptiAdvanced -> IO MX casadi__OptiAdvanced__objective x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__objective errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_objective :: OptiAdvancedClass a => a -> IO MX optiAdvanced_objective x = casadi__OptiAdvanced__objective (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__problem_dirty" c_casadi__OptiAdvanced__problem_dirty :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO CInt casadi__OptiAdvanced__problem_dirty :: OptiAdvanced -> IO Bool casadi__OptiAdvanced__problem_dirty x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__problem_dirty errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_problem_dirty :: OptiAdvancedClass a => a -> IO Bool optiAdvanced_problem_dirty x = casadi__OptiAdvanced__problem_dirty (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__res__0" c_casadi__OptiAdvanced__res__0 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO (Ptr (StdMap StdString (Ptr DM'))) casadi__OptiAdvanced__res__0 :: OptiAdvanced -> IO (M.Map String DM) casadi__OptiAdvanced__res__0 x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__res__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_res__0 :: OptiAdvancedClass a => a -> IO (M.Map String DM) optiAdvanced_res__0 x = casadi__OptiAdvanced__res__0 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__res__1" c_casadi__OptiAdvanced__res__1 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr (StdMap StdString (Ptr DM')) -> IO () casadi__OptiAdvanced__res__1 :: OptiAdvanced -> M.Map String DM -> IO () casadi__OptiAdvanced__res__1 x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__res__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return () -- classy wrapper optiAdvanced_res__1 :: OptiAdvancedClass a => a -> M.Map String DM -> IO () optiAdvanced_res__1 x = casadi__OptiAdvanced__res__1 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__set_meta" c_casadi__OptiAdvanced__set_meta :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> Ptr MetaVar' -> IO () casadi__OptiAdvanced__set_meta :: OptiAdvanced -> MX -> MetaVar -> IO () casadi__OptiAdvanced__set_meta x0 x1 x2 = do x0' <- marshal x0 x1' <- marshal x1 x2' <- marshal x2 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__set_meta errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' marshalFree x2 x2' return () -- classy wrapper optiAdvanced_set_meta :: OptiAdvancedClass a => a -> MX -> MetaVar -> IO () optiAdvanced_set_meta x = casadi__OptiAdvanced__set_meta (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__set_meta_con" c_casadi__OptiAdvanced__set_meta_con :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> Ptr MetaCon' -> IO () casadi__OptiAdvanced__set_meta_con :: OptiAdvanced -> MX -> MetaCon -> IO () casadi__OptiAdvanced__set_meta_con x0 x1 x2 = do x0' <- marshal x0 x1' <- marshal x1 x2' <- marshal x2 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__set_meta_con errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' marshalFree x2 x2' return () -- classy wrapper optiAdvanced_set_meta_con :: OptiAdvancedClass a => a -> MX -> MetaCon -> IO () optiAdvanced_set_meta_con x = casadi__OptiAdvanced__set_meta_con (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__show_infeasibilities__0" c_casadi__OptiAdvanced__show_infeasibilities__0 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__show_infeasibilities__0 :: OptiAdvanced -> IO () casadi__OptiAdvanced__show_infeasibilities__0 x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__show_infeasibilities__0 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_show_infeasibilities__0 :: OptiAdvancedClass a => a -> IO () optiAdvanced_show_infeasibilities__0 x = casadi__OptiAdvanced__show_infeasibilities__0 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__show_infeasibilities__1" c_casadi__OptiAdvanced__show_infeasibilities__1 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CDouble -> IO () casadi__OptiAdvanced__show_infeasibilities__1 :: OptiAdvanced -> Double -> IO () casadi__OptiAdvanced__show_infeasibilities__1 x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__show_infeasibilities__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return () -- classy wrapper optiAdvanced_show_infeasibilities__1 :: OptiAdvancedClass a => a -> Double -> IO () optiAdvanced_show_infeasibilities__1 x = casadi__OptiAdvanced__show_infeasibilities__1 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__solve_actual" c_casadi__OptiAdvanced__solve_actual :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr (StdMap StdString (Ptr DM')) -> IO (Ptr (StdMap StdString (Ptr DM'))) casadi__OptiAdvanced__solve_actual :: OptiAdvanced -> M.Map String DM -> IO (M.Map String DM) casadi__OptiAdvanced__solve_actual x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__solve_actual errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_solve_actual :: OptiAdvancedClass a => a -> M.Map String DM -> IO (M.Map String DM) optiAdvanced_solve_actual x = casadi__OptiAdvanced__solve_actual (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__solve_prepare" c_casadi__OptiAdvanced__solve_prepare :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO () casadi__OptiAdvanced__solve_prepare :: OptiAdvanced -> IO () casadi__OptiAdvanced__solve_prepare x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__solve_prepare errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP () <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return () -- classy wrapper optiAdvanced_solve_prepare :: OptiAdvancedClass a => a -> IO () optiAdvanced_solve_prepare x = casadi__OptiAdvanced__solve_prepare (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__solved" c_casadi__OptiAdvanced__solved :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO CInt casadi__OptiAdvanced__solved :: OptiAdvanced -> IO Bool casadi__OptiAdvanced__solved x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__solved errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_solved :: OptiAdvancedClass a => a -> IO Bool optiAdvanced_solved x = casadi__OptiAdvanced__solved (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__solver_dirty" c_casadi__OptiAdvanced__solver_dirty :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO CInt casadi__OptiAdvanced__solver_dirty :: OptiAdvanced -> IO Bool casadi__OptiAdvanced__solver_dirty x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__solver_dirty errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_solver_dirty :: OptiAdvancedClass a => a -> IO Bool optiAdvanced_solver_dirty x = casadi__OptiAdvanced__solver_dirty (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__symvar__0" c_casadi__OptiAdvanced__symvar__0 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> CInt -> IO (Ptr (StdVec (Ptr MX'))) casadi__OptiAdvanced__symvar__0 :: OptiAdvanced -> MX -> VariableType -> IO (Vector MX) casadi__OptiAdvanced__symvar__0 x0 x1 x2 = do x0' <- marshal x0 x1' <- marshal x1 x2' <- marshal x2 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__symvar__0 errStrPtrP x0' x1' x2' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' marshalFree x2 x2' return ret -- classy wrapper optiAdvanced_symvar__0 :: OptiAdvancedClass a => a -> MX -> VariableType -> IO (Vector MX) optiAdvanced_symvar__0 x = casadi__OptiAdvanced__symvar__0 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__symvar__1" c_casadi__OptiAdvanced__symvar__1 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> Ptr MX' -> IO (Ptr (StdVec (Ptr MX'))) casadi__OptiAdvanced__symvar__1 :: OptiAdvanced -> MX -> IO (Vector MX) casadi__OptiAdvanced__symvar__1 x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__symvar__1 errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_symvar__1 :: OptiAdvancedClass a => a -> MX -> IO (Vector MX) optiAdvanced_symvar__1 x = casadi__OptiAdvanced__symvar__1 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__symvar__2" c_casadi__OptiAdvanced__symvar__2 :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> IO (Ptr (StdVec (Ptr MX'))) casadi__OptiAdvanced__symvar__2 :: OptiAdvanced -> IO (Vector MX) casadi__OptiAdvanced__symvar__2 x0 = do x0' <- marshal x0 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__symvar__2 errStrPtrP x0' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' return ret -- classy wrapper optiAdvanced_symvar__2 :: OptiAdvancedClass a => a -> IO (Vector MX) optiAdvanced_symvar__2 x = casadi__OptiAdvanced__symvar__2 (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__x_describe" c_casadi__OptiAdvanced__x_describe :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CLLong -> IO (Ptr StdString) casadi__OptiAdvanced__x_describe :: OptiAdvanced -> Int -> IO String casadi__OptiAdvanced__x_describe x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__x_describe errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_x_describe :: OptiAdvancedClass a => a -> Int -> IO String optiAdvanced_x_describe x = casadi__OptiAdvanced__x_describe (castOptiAdvanced x) -- direct wrapper foreign import ccall unsafe "casadi__OptiAdvanced__x_lookup" c_casadi__OptiAdvanced__x_lookup :: Ptr (Ptr StdString) -> Ptr OptiAdvanced' -> CLLong -> IO (Ptr MX') casadi__OptiAdvanced__x_lookup :: OptiAdvanced -> Int -> IO MX casadi__OptiAdvanced__x_lookup x0 x1 = do x0' <- marshal x0 x1' <- marshal x1 errStrPtrP <- new nullPtr ret0 <- c_casadi__OptiAdvanced__x_lookup errStrPtrP x0' x1' errStrPtr <- peek errStrPtrP free errStrPtrP ret <- if errStrPtr == nullPtr then wrapReturn ret0 else wrapReturn errStrPtr >>= (error . formatException) marshalFree x0 x0' marshalFree x1 x1' return ret -- classy wrapper optiAdvanced_x_lookup :: OptiAdvancedClass a => a -> Int -> IO MX optiAdvanced_x_lookup x = casadi__OptiAdvanced__x_lookup (castOptiAdvanced x)