casadi 3.6.3__cp35-none-win_amd64.whl → 3.6.5__cp35-none-win_amd64.whl

casadi/include/sleqp/pub_dyn.h

@@ -0,0 +1,140 @@
+#ifndef SLEQP_PUB_DYN_H
+#define SLEQP_PUB_DYN_H
+
+#include "sleqp/pub_func.h"
+
+/**
+ * @file pub_dyn.h
+ * @brief Definition of dynamic functions.
+ *
+ * @defgroup dynamic Dynamic nonlinear functions
+ *
+ * Dynamic functions extend the evaluation of the objective and constraints
+ * to include limited accuracy. Specifically, the original objective
+ * \f$ f(x) \f$ is replaced by a counterpart \f$ f(x; \epsilon) \f$
+ * with an accuracy limited by \f$ \epsilon \f$  satisfying that
+ *
+ * \f[ | f(x; \epsilon) - f(x) | \leq \epsilon. \f]
+ *
+ * It is assumed that the value of \f$ \epsilon \f$ can be chosen freely,
+ * trading off computational complexity against accuracy.
+ * The same should be true for the constraints \f$ c(x) \f$.
+ * Consequently, the combined function, given by
+ * by
+ *
+ * \f[
+ * \Pi(x, w^{f}, w^{c}) := w^f \cdot f(x)
+ *   + \sum_{i=1}^{m} w^{c}_i \cdot
+ * \left( \max(c_i(x) - u_i, 0) + \max(l_i - c_i(x), 0) \right)
+ * \f]
+ *
+ * is subject to a limited accuracy (where \f$ w^{f} > 0 \f$
+ * and \f$ w^{c} \in \R^{m}_{> 0} \f$ ). Specifically,
+ * \f$ \Pi(x, w^{f}, w^{c}) \f$ is replaced by
+ * \f$ \Pi(x, w^{f}, w^{c}; \epsilon^{f}, \epsilon^{c}) \f$
+ * given by
+ *
+ * \f[
+ * \Pi(x, w^{f}, w^{c}; \epsilon^{f}, \epsilon^{c})
+ *  := w^f \cdot f(x; \epsilon^{f})
+ *   + \sum_{i=1}^{m} w^{c}_i \cdot
+ * \left( \max(c_i(x; \epsilon^{c}_i) - u_i, 0)
+ *      + \max(l_i - c_i(x; \epsilon^{c}_i), 0) \right) \f]
+ *
+ * where \f$ \epsilon^{f} > 0 \f$
+ * and \f$ \epsilon^{c} \in \R^{m}_{> 0} \f$.
+ **/
+
+/**
+ * Evaluates the dynamic function at the current input vector. Given
+ * the current error bound \f$ \epsilon > 0 \f$ and weights
+ * \f$ w^{f} > 0 \f$ and \f$ w^{c} \in \R^{m}_{> 0} \f$,
+ * the evaluation should satisfy
+ *
+ * \f[ \hat{\epsilon} := |\Pi(x, w^{f}, w^{c})
+ *    - \Pi(x, w^{f}, w^{c}; \epsilon^{f}, \epsilon^{c} )| \leq \epsilon.
+ * \f]
+ *
+ * The choice of the values of \f$ \epsilon^{f} \f$ and \f$ \epsilon^{c} \f$
+ * (the distribution of the error with respect to the objective and constraints)
+ * are up to the user.
+ *
+ * @param[in]     func        The function
+ * @param[out]    obj_val     The function value \f$ f(x) \f$
+ * @param[out]    cons_val    The value of the constraint function \f$ c(x) \f$
+ * @param[out]    error       The actual error \f$ \hat{\epsilon} \f$
+ * @param[in,out] func_data   The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_DYN_FUNC_EVAL)(SleqpFunc* func,
+                                             double* obj_val,
+                                             SleqpVec* cons_val,
+                                             double* error,
+                                             void* func_data);
+
+/**
+ * Sets the error bound \f$ \epsilon \f$ for subsequent evaluations
+ *
+ * @param[in]     func            The function
+ * @param[in]     error_bound     The error bound \f$ \epsilon \f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_DYN_FUNC_SET_ERROR_BOUND)(SleqpFunc* func,
+                                                        double error_bound,
+                                                        void* func_data);
+
+/**
+ * Sets the objective weight \f$ w^{f} \f$ for subsequent evaluations
+ *
+ * @param[in]     func            The function
+ * @param[in]     obj_weight      The objective weight \f$ w^{f} \f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_DYN_FUNC_SET_OBJ_WEIGHT)(SleqpFunc* func,
+                                                       double obj_weight,
+                                                       void* func_data);
+
+/**
+ * Sets the constraint weights \epsilon^{c} for subsequent evaluations
+ *
+ * @param[in]     func            The function
+ * @param[in]     cons_weights    The constraint weights \f$ \epsilon^{c} \f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_DYN_FUNC_SET_CONS_WEIGHTS)(
+  SleqpFunc* func,
+  const double* cons_weights,
+  void* func_data);
+
+typedef struct
+{
+  SLEQP_FUNC_SET set_value;
+  SLEQP_FUNC_NONZEROS nonzeros;
+  SLEQP_DYN_FUNC_SET_ERROR_BOUND set_error_bound;
+  SLEQP_DYN_FUNC_SET_OBJ_WEIGHT set_obj_weight;
+  SLEQP_DYN_FUNC_SET_CONS_WEIGHTS set_cons_weights;
+  SLEQP_DYN_FUNC_EVAL eval;
+  SLEQP_FUNC_OBJ_GRAD obj_grad;
+  SLEQP_FUNC_CONS_JAC cons_jac;
+  SLEQP_FUNC_HESS_PROD hess_prod;
+  SLEQP_FUNC_FREE func_free;
+} SleqpDynFuncCallbacks;
+
+/**
+ * Creates a new dynamic function
+ * @param[out] fstar            A pointer to the function to be created
+ * @param[in]  callbacks        The dynamic function callbacks
+ * @param[in]  num_variables    The number of variables
+ * @param[in]  num_constraints  The number of constraints
+ * @param[in]  func_data        The function data
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_dyn_func_create(SleqpFunc** fstar,
+                      SleqpDynFuncCallbacks* callbacks,
+                      int num_variables,
+                      int num_constraints,
+                      void* func_data);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_dyn_func_set_callbacks(SleqpFunc* func, SleqpDynFuncCallbacks* callbacks);
+
+#endif /* SLEQP_PUB_DYN_H */

casadi/include/sleqp/pub_error.h

@@ -0,0 +1,50 @@
+#ifndef SLEQP_PUB_ERROR_H
+#define SLEQP_PUB_ERROR_H
+
+/**
+ * @file pub_error.h
+ * @brief Error handling.
+ **/
+
+#include "pub_types.h"
+
+/**
+ * Returns the type of the current error
+ **/
+SLEQP_EXPORT SLEQP_ERROR_TYPE
+sleqp_error_type();
+
+/**
+ * Returns the message associated
+ * with  the current error
+ **/
+SLEQP_EXPORT const char*
+sleqp_error_msg();
+
+/**
+ * Sets the current error. To be used by @ref sleqp_raise
+ **/
+SLEQP_EXPORT void
+sleqp_set_error(const char* file,
+                int line,
+                const char* func,
+                SLEQP_ERROR_TYPE error_type,
+                const char* fmt,
+                ...) SLEQP_FORMAT_PRINTF(5, 6);
+
+/**
+ * Raises an error with the given type and message
+ **/
+#define sleqp_raise(error_type, fmt, ...)                                      \
+  do                                                                           \
+  {                                                                            \
+    sleqp_set_error(__FILE__,                                                  \
+                    __LINE__,                                                  \
+                    __PRETTY_FUNCTION__,                                       \
+                    error_type,                                                \
+                    fmt,                                                       \
+                    ##__VA_ARGS__);                                            \
+    return SLEQP_ERROR;                                                        \
+  } while (false)
+
+#endif /* SLEQP_PUB_ERROR_H */

casadi/include/sleqp/pub_func.h

@@ -0,0 +1,257 @@
+#ifndef PUB_FUNC_H
+#define PUB_FUNC_H
+
+/**
+ * @file pub_func.h
+ * @brief Definition of nonlinear functions.
+ **/
+
+#include "sleqp/pub_hess_struct.h"
+#include "sparse/pub_mat.h"
+#include "sparse/pub_vec.h"
+
+/**
+ * @defgroup function Nonlinear functions
+ * @{
+ *
+ * A function is given by an objective
+ * \f$ f : \R^n \to \R \f$
+ * and constraints
+ * \f$ c : \R^n \to \R^{m} \f$.
+ *
+ * The functions are assumed to be twice continuously
+ * differentiable. Function, gradient, and Hessian evaluations are
+ * supposed to be provided by the user in the form of callbacks.
+ **/
+
+typedef struct SleqpFunc SleqpFunc;
+
+/**
+ * The reason for setting the primal point
+ **/
+typedef enum
+{
+  /** No reason **/
+  SLEQP_VALUE_REASON_NONE,
+  /** Initial step **/
+  SLEQP_VALUE_REASON_INIT,
+  /** Checking derivatives **/
+  SLEQP_VALUE_REASON_CHECKING_DERIV,
+  /** Accepted trial step **/
+  SLEQP_VALUE_REASON_ACCEPTED_ITERATE,
+  /** New trial step **/
+  SLEQP_VALUE_REASON_TRYING_ITERATE,
+  /** New SOC trial step **/
+  SLEQP_VALUE_REASON_TRYING_SOC_ITERATE,
+  /** Rejected trial step **/
+  SLEQP_VALUE_REASON_REJECTED_ITERATE,
+} SLEQP_VALUE_REASON;
+
+/**
+ * Type of the function
+ **/
+typedef enum
+{
+  /** Regular function **/
+  SLEQP_FUNC_TYPE_REGULAR,
+  /** Least-squares function @see least_squares **/
+  SLEQP_FUNC_TYPE_LSQ,
+  /** Dynamic function @see dynamic **/
+  SLEQP_FUNC_TYPE_DYNAMIC
+} SLEQP_FUNC_TYPE;
+
+/**
+ * Sets the current primal point
+ *
+ * @param[in]     func            The function
+ * @param[in]     value           The value
+ * @param[in]     reason          The reason for setting \f$ x \f$
+ * @param[out]    reject          Whether to manually reject the step
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_SET)(SleqpFunc* func,
+                                        SleqpVec* value,
+                                        SLEQP_VALUE_REASON reason,
+                                        bool* reject,
+                                        void* func_data);
+
+/**
+ * Queries the number of nonzeros of the function at the
+ * current primal point
+ *
+ * @param[in]     func            The function
+ * @param[out]    obj_grad_nnz    The number of nonzeros of the objective
+ *gradient \f$ \nabla f(x) \f$
+ * @param[out]    cons_val_nnz    The number of nonzeros of the constraint
+ *function \f$ c(x) \f$
+ * @param[out]    cons_jac_nnz    The number of nonzeros of the constraint
+ *Jacobian \f$ J_c(x) \f$
+ * @param[out]    cons_jac_nnz    The number of nonzeros of Hessian products
+ * \f$ \nabla_{xx} L(x, \lambda) \f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_NONZEROS)(SleqpFunc* func,
+                                             int* obj_grad_nnz,
+                                             int* cons_val_nnz,
+                                             int* cons_jac_nnz,
+                                             int* hess_prod_nnz,
+                                             void* func_data);
+
+/**
+ * Evaluates the objective \f$ f \f$ at the current primal point
+ *
+ * @param[in]     func            The function
+ * @param[out]    obj_val         The objective value \f$ f(x) \f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_OBJ_VAL)(SleqpFunc* func,
+                                            double* obj_val,
+                                            void* func_data);
+
+/**
+ * Evaluates the objective gradient \f$ \nabla f \f$ at the current
+ * primal point
+ *
+ * @param[in]     func            The function
+ * @param[out]    obj_grad        The objective gradient \f$ \nabla f(x) \f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_OBJ_GRAD)(SleqpFunc* func,
+                                             SleqpVec* obj_grad,
+                                             void* func_data);
+
+/**
+ * Evaluates the constraints \f$ c \f$ at the current primal point
+ *
+ * @param[in]     func            The function
+ * @param[out]    cons_val        The value of the constraint function \f$ c(x)
+ *\f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_CONS_VAL)(SleqpFunc* func,
+                                             SleqpVec* cons_val,
+                                             void* func_data);
+
+/**
+ * Evaluates the constraing Jacobian \f$ J_c \f$ at the current primal point
+ *
+ * @param[in]     func            The function
+ * @param[out]    cons_jac        The constraint Jacobian \f$ J_c(x) \f$
+ * @param[in,out] func_data       The function data
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_CONS_JAC)(SleqpFunc* func,
+                                             SleqpMat* cons_jac,
+                                             void* func_data);
+
+/**
+ * Evaluates the product of the Hessian of the Lagrangian function.
+ * The Lagrangian function is given by:
+ *
+ * \f[
+ * L(x, \lambda) := f(x) + \langle \lambda, c(x) \rangle
+ * \f]
+ *
+ * The product with a direction \f$ d \f$ is then:
+ * \f[
+ * \nabla_{xx} L(x, \lambda) d
+ * = \left( \nabla_{xx} f(x) d
+ *   + \sum_{i=1}^{m} \lambda_i  \nabla_{xx} c_i(x) d \right)
+ * \f]
+ *
+ * @param[in]     func              The function
+ * @param[in]     direction         The direction \f$ d \f$
+ * @param[in]     cons_duals        The values \f$ \lambda \f$
+ * @param[out]    product           The resulting product
+ * @param[in,out] func_data         The function data
+ *
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_HESS_PROD)(SleqpFunc* func,
+                                              const SleqpVec* direction,
+                                              const SleqpVec* cons_duals,
+                                              SleqpVec* product,
+                                              void* func_data);
+
+/**
+ * Cleans up any allocated memory stored in the function data.
+ *
+ * @param[in,out] func_data  The function data
+ *
+ **/
+typedef SLEQP_RETCODE (*SLEQP_FUNC_FREE)(void* func_data);
+
+typedef struct
+{
+  SLEQP_FUNC_SET set_value;
+  SLEQP_FUNC_NONZEROS nonzeros;
+  SLEQP_FUNC_OBJ_VAL obj_val;
+  SLEQP_FUNC_OBJ_GRAD obj_grad;
+  SLEQP_FUNC_CONS_VAL cons_val;
+  SLEQP_FUNC_CONS_JAC cons_jac;
+  SLEQP_FUNC_HESS_PROD hess_prod;
+  SLEQP_FUNC_FREE func_free;
+} SleqpFuncCallbacks;
+
+/**
+ * Creates a new function
+ *
+ * @param[out] fstar            A pointer to the function to be created
+ * @param[in]  callbacks        A callback to the function callbacks
+ * @param[in]  num_variables    The number of variables
+ * @param[in]  num_constraints  The number of constraints
+ * @param[in]  func_data        User-provided function data
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_func_create(SleqpFunc** fstar,
+                  SleqpFuncCallbacks* callbacks,
+                  int num_variables,
+                  int num_constraints,
+                  void* func_data);
+
+/**
+ * Returns the number of variables \f$ n \f$.
+ **/
+SLEQP_EXPORT int
+sleqp_func_num_vars(const SleqpFunc* func);
+
+/**
+ * Returns the number of constraints \f$ m \f$.
+ **/
+SLEQP_EXPORT int
+sleqp_func_num_cons(const SleqpFunc* func);
+
+/**
+ * Sets the callbacks of this function to the specified ones
+ *
+ * @param[in]     func            The function
+ * @param[in]     callbacks       The new callbacks
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_func_set_callbacks(SleqpFunc* func, SleqpFuncCallbacks* callbacks);
+
+/**
+ * Returns the Hessian structure of this function
+ *
+ * @param[in]     func            The function
+ *
+ **/
+SLEQP_EXPORT
+SleqpHessStruct*
+sleqp_func_hess_struct(SleqpFunc* func);
+
+/**
+ * Returns the function data associated with the given function.
+ **/
+SLEQP_EXPORT void*
+sleqp_func_get_data(SleqpFunc* func);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_func_capture(SleqpFunc* func);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_func_release(SleqpFunc** fstar);
+
+/**
+ * @}
+ **/
+
+#endif /* PUB_FUNC_H */

casadi/include/sleqp/pub_hess_struct.h

@@ -0,0 +1,105 @@
+#ifndef SLEQP_PUB_HESS_STRUCT_H
+#define SLEQP_PUB_HESS_STRUCT_H
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+
+/**
+ * @file pub_hess_struct.h
+ * @brief Definition of problem block structure.
+ **/
+
+/**
+ *
+ * Hessian structure of the Lagrangian
+ *
+ * \f[ L(x, \lambda, \mu) = f(x) + \langle \lambda, c \rangle + \langle 1, \mu
+ *\rangle \f].
+ *
+ * The Hessian \f$ H_L \f$ is assumed to consist of a number of \f$k\f$ blocks,
+ * given in terms of indices \f$ 1 = j_1 < j_2 < \ldots < j_{k+1} \leq n \f$.
+ * All non-zero entries \f$ (i, j) \f$ must satisfy that
+ * \f$ j_l \leq i, j < j_{l + 1} \f$ for some \f$ l = 1, \ldots, k \f$.
+ *
+ * The default is to assume one block of size \f$ n \f$, implying
+ * no particular structure of the Hessian.
+ *
+ * If \f$ j_{k+1} < n \f$, then the range from \f$ j_{k+1} \f$ to \f$ n \f$
+ * must only contain zero entries, i.e., combinations of linear constraints
+ * and variables.
+ *
+ **/
+typedef struct SleqpHessStruct SleqpHessStruct;
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_create(SleqpHessStruct** star, int dimension, bool empty);
+
+/**
+ * Returns the number \f$ k \f$ of blocks.
+ *
+ * @param[in]  hessian_struct  The Hessian structure
+ * @returns                    The number \f$ k \f$ of blocks
+ **/
+SLEQP_EXPORT int
+sleqp_hess_struct_num_blocks(const SleqpHessStruct* hessian_struct);
+
+/**
+ * Returns the \f$ l \f$-th block of the Hessian
+ *
+ * @param[in]  hessian_struct  The Hessian structure
+ * @param[in]  block           The index \f$ l \f$ of the block
+ * @param[out] begin           The 0-based index \f$ j_l \f$
+ * @param[out] end             The 0-based index \f$ j_{l+1} \f$
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_block_range(const SleqpHessStruct* hessian_struct,
+                              int block,
+                              int* begin,
+                              int* end);
+
+/**
+ * Pushes a new block into the Hessian
+ *
+ * @param[in]  hessian_struct  The Hessian structure
+ * @param[out] end             The 0-based index \f$ j_{l+1} \f$
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_push_block(SleqpHessStruct* hessian_struct, int end);
+
+/**
+ * Clears the Hessian structure, i.e., sets \f$ k = 0 \f$
+ *
+ * @param[in]  hessian_struct  The Hessian structure
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_clear(SleqpHessStruct* hessian_struct);
+
+/**
+ * Returns the linear range
+ *
+ * @param[in]   hessian_struct  The Hessian structure
+ * @param[out]  begin           The value \f$ j_{k + 1} \f$
+ * @param[out]  end             The value \f$ n \f$
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_lin_range(const SleqpHessStruct* hessian_struct,
+                            int* begin,
+                            int* end);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_copy(const SleqpHessStruct* source, SleqpHessStruct* target);
+
+/**
+ * Prints the Hessian structure
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_fprintf(SleqpHessStruct* hessian_struct, FILE* output);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_capture(SleqpHessStruct* hessian_struct);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_hess_struct_release(SleqpHessStruct** star);
+
+#endif /* SLEQP_PUB_HESS_STRUCT_H */

casadi/include/sleqp/pub_iterate.h

@@ -0,0 +1,88 @@
+#ifndef SLEQP_PUB_ITERATE_H
+#define SLEQP_PUB_ITERATE_H
+
+/**
+ * @file pub_iterate.h
+ * @brief Definition of iterate.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_problem.h"
+#include "sleqp/pub_working_set.h"
+
+#include "sparse/pub_mat.h"
+#include "sparse/pub_vec.h"
+
+typedef struct SleqpIterate SleqpIterate;
+
+/**
+ * Create a new iterate
+ *
+ * @param[in,out] star    A pointer to the newly created iterate
+ * @param[in] problem     The underlying problem
+ * @param[in] x           The point of the iterate
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_iterate_create(SleqpIterate** star,
+                     SleqpProblem* problem,
+                     const SleqpVec* x);
+
+/**
+ * The current point. Has dimension = num_variables.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_iterate_primal(const SleqpIterate* iterate);
+
+/**
+ * The current function value
+ **/
+SLEQP_EXPORT double
+sleqp_iterate_obj_val(const SleqpIterate* iterate);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_iterate_set_obj_val(SleqpIterate* iterate, double value);
+
+/**
+ * The current function gradient. Has dimension = num_variables.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_iterate_obj_grad(const SleqpIterate* iterate);
+
+/**
+ * The current constraint values. Has dimension = num_constraints.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_iterate_cons_val(const SleqpIterate* iterate);
+
+/**
+ * The Jacobian of the constraitns at the current iterate.
+ * Has num_constraints many rows, num_variables many columns.
+ */
+SLEQP_EXPORT SleqpMat*
+sleqp_iterate_cons_jac(const SleqpIterate* iterate);
+
+/**
+ * The current working set.
+ **/
+SLEQP_EXPORT SleqpWorkingSet*
+sleqp_iterate_working_set(const SleqpIterate* iterate);
+
+/**
+ * The dual values of the constraints. Has dimension = num_constraints.
+ */
+SLEQP_EXPORT SleqpVec*
+sleqp_iterate_cons_dual(const SleqpIterate* iterate);
+
+/**
+ * The dual values of the variable bounds. Has dimension = num_variables.
+ */
+SLEQP_EXPORT SleqpVec*
+sleqp_iterate_vars_dual(const SleqpIterate* iterate);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_iterate_capture(SleqpIterate* iterate);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_iterate_release(SleqpIterate** star);
+
+#endif /* SLEQP_PUB_ITERATE_H */