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

casadi/include/sleqp/pub_settings.h

@@ -0,0 +1,162 @@
+#ifndef SLEQP_PUB_SETTINGS_H
+#define SLEQP_PUB_SETTINGS_H
+
+/**
+ * @file pub_settings.h
+ * @brief Definition of settings.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+
+typedef enum
+{
+  SLEQP_SETTINGS_ENUM_DERIV_CHECK = 0,
+  SLEQP_SETTINGS_ENUM_HESS_EVAL,
+  SLEQP_SETTINGS_ENUM_DUAL_ESTIMATION_TYPE,
+  SLEQP_SETTINGS_ENUM_FLOAT_WARNING_FLAGS,
+  SLEQP_SETTINGS_ENUM_FLOAT_ERROR_FLAGS,
+  SLEQP_SETTINGS_ENUM_BFGS_SIZING,
+  SLEQP_SETTINGS_ENUM_TR_SOLVER,
+  SLEQP_SETTINGS_ENUM_POLISHING_TYPE,
+  SLEQP_SETTINGS_ENUM_STEP_RULE,
+  SLEQP_SETTINGS_ENUM_LINESEARCH,
+  SLEQP_SETTINGS_ENUM_PARAMETRIC_CAUCHY,
+  SLEQP_SETTINGS_ENUM_INITIAL_TR_CHOICE,
+  SLEQP_SETTINGS_ENUM_AUG_JAC_METHOD,
+  SLEQP_NUM_ENUM_SETTINGS
+} SLEQP_SETTINGS_ENUM;
+
+typedef enum
+{
+  SLEQP_SETTINGS_INT_NUM_QUASI_NEWTON_ITERATES = 0,
+  SLEQP_SETTINGS_INT_MAX_NEWTON_ITERATIONS,
+  SLEQP_SETTINGS_INT_NUM_THREADS,
+  SLEQP_NUM_INT_SETTINGS
+} SLEQP_SETTINGS_INT;
+
+typedef enum
+{
+  SLEQP_SETTINGS_BOOL_PERFORM_NEWTON_STEP = 0,
+  SLEQP_SETTINGS_BOOL_GLOBAL_PENALTY_RESETS,
+  SLEQP_SETTINGS_BOOL_PERFORM_SOC,
+  SLEQP_SETTINGS_BOOL_USE_QUADRATIC_MODEL,
+  SLEQP_SETTINGS_BOOL_ALWAYS_WARM_START_LP,
+  SLEQP_SETTINGS_BOOL_ENABLE_RESTORATION_PHASE,
+  SLEQP_SETTINGS_BOOL_ENABLE_PREPROCESSOR,
+  SLEQP_SETTINGS_BOOL_LP_RESOLVES,
+  SLEQP_NUM_BOOL_SETTINGS
+} SLEQP_SETTINGS_BOOL;
+
+typedef enum
+{
+  SLEQP_SETTINGS_REAL_ZERO_EPS = 0,
+  SLEQP_SETTINGS_REAL_EPS,
+  SLEQP_SETTINGS_REAL_OBJ_LOWER,
+  SLEQP_SETTINGS_REAL_DERIV_PERTURBATION,
+  SLEQP_SETTINGS_REAL_DERIV_TOL,
+  SLEQP_SETTINGS_REAL_CAUCHY_TAU,
+  SLEQP_SETTINGS_REAL_CAUCHY_ETA,
+  SLEQP_SETTINGS_REAL_LINESEARCH_TAU,
+  SLEQP_SETTINGS_REAL_LINESEARCH_ETA,
+  SLEQP_SETTINGS_REAL_LINESEARCH_CUTOFF,
+  SLEQP_SETTINGS_REAL_FEAS_TOL,
+  SLEQP_SETTINGS_REAL_SLACK_TOL,
+  SLEQP_SETTINGS_REAL_STAT_TOL,
+  SLEQP_SETTINGS_REAL_ACCEPTED_REDUCTION,
+  SLEQP_SETTINGS_REAL_DEADPOINT_BOUND,
+  SLEQP_NUM_REAL_SETTINGS
+} SLEQP_SETTINGS_REAL;
+
+typedef struct SleqpSettings SleqpSettings;
+
+SLEQP_EXPORT const char*
+sleqp_settings_enum_name(SLEQP_SETTINGS_ENUM settings);
+
+SLEQP_EXPORT const char*
+sleqp_settings_enum_desc(SLEQP_SETTINGS_ENUM settings);
+
+SLEQP_EXPORT const char*
+sleqp_settings_int_name(SLEQP_SETTINGS_INT settings);
+
+SLEQP_EXPORT const char*
+sleqp_settings_int_desc(SLEQP_SETTINGS_INT settings);
+
+SLEQP_EXPORT const char*
+sleqp_settings_bool_name(SLEQP_SETTINGS_BOOL settings);
+
+SLEQP_EXPORT const char*
+sleqp_settings_bool_desc(SLEQP_SETTINGS_BOOL settings);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_create(SleqpSettings** star);
+
+SLEQP_EXPORT const char*
+sleqp_settings_real_name(SLEQP_SETTINGS_REAL param);
+
+SLEQP_EXPORT const char*
+sleqp_settings_real_desc(SLEQP_SETTINGS_REAL param);
+
+SLEQP_EXPORT double
+sleqp_settings_real_value(const SleqpSettings* settings,
+                          SLEQP_SETTINGS_REAL param);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_set_real_value(SleqpSettings* setting,
+                              SLEQP_SETTINGS_REAL param,
+                              double value);
+
+SLEQP_EXPORT
+int
+sleqp_settings_enum_value(const SleqpSettings* settings,
+                          SLEQP_SETTINGS_ENUM option);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_set_enum_value(SleqpSettings* settings,
+                              SLEQP_SETTINGS_ENUM option,
+                              int value);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_set_enum_value_from_string(SleqpSettings* settings,
+                                          SLEQP_SETTINGS_ENUM option,
+                                          const char* value);
+
+SLEQP_EXPORT
+int
+sleqp_settings_int_value(const SleqpSettings* settings,
+                         SLEQP_SETTINGS_INT option);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_set_int_value(SleqpSettings* settings,
+                             SLEQP_SETTINGS_INT option,
+                             int value);
+
+SLEQP_EXPORT
+bool
+sleqp_settings_bool_value(const SleqpSettings* settings,
+                          SLEQP_SETTINGS_BOOL option);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_set_bool_value(SleqpSettings* settings,
+                              SLEQP_SETTINGS_BOOL option,
+                              bool value);
+
+/**
+ * Read settings from file on the disk and
+ * update relevant parts of the given settings
+ *
+ * @param[in,out] settings           Current settings
+ * @param[in]     settings_filename  Name of settings file
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_read_file(SleqpSettings* settings,
+                         const char* settings_filename);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_capture(SleqpSettings* settings);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_settings_release(SleqpSettings** star);
+
+#endif /* SLEQP_PUB_SETTINGS_H */

casadi/include/sleqp/pub_solver.h

@@ -0,0 +1,155 @@
+#ifndef SLEQP_PUB_SOLVER_H
+#define SLEQP_PUB_SOLVER_H
+
+/**
+ * @file pub_solver.h
+ * @brief Definition of the solver structure.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_iterate.h"
+#include "sleqp/pub_problem.h"
+#include "sleqp/pub_scale.h"
+#include "sleqp/pub_settings.h"
+
+typedef struct SleqpSolver SleqpSolver;
+
+typedef SLEQP_RETCODE (*SLEQP_ACCEPTED_ITERATE)(SleqpSolver* solver,
+                                                SleqpIterate* iterate,
+                                                void* callback_data);
+
+typedef SLEQP_RETCODE (*SLEQP_PERFORMED_ITERATION)(SleqpSolver* solver,
+                                                   void* callback_data);
+
+typedef SLEQP_RETCODE (*SLEQP_FINISHED)(SleqpSolver* solver,
+                                        SleqpIterate* iterate,
+                                        void* callback_data);
+
+typedef struct SleqpSolver SleqpSolver;
+
+/**
+ * Creates a solver
+ *
+ * @param[out] star            A pointer to the solver to be created
+ * @param[in]  problem         The underlying problem
+ * @param[in]  settings         The solver settings
+ * @param[in]  primal          The initial solution
+ * @param[in]  scaling_data    The scaling to be used (may be `NULL`)
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_create(SleqpSolver** star,
+                    SleqpProblem* problem,
+                    SleqpVec* primal,
+                    SleqpScaling* scaling_data);
+
+/**
+ * Solves the problem by performing iteration starting from the current solution
+ *
+ * @param[in]  solver           The solver
+ * @param[in]  num_iterations   The number of iterations to be performed, or
+ *@ref SLEQP_NONE
+ * @param[in]  time_limit       A time limit in seconds, or @ref SLEQP_NONE
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_solve(SleqpSolver* solver,
+                   int max_num_iterations,
+                   double time_limit);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_real_state(const SleqpSolver* solver,
+                        SLEQP_SOLVER_STATE_REAL state,
+                        double* value);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_int_state(const SleqpSolver* solver,
+                       SLEQP_SOLVER_STATE_INT state,
+                       int* value);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_vec_state(const SleqpSolver* solver,
+                       SLEQP_SOLVER_STATE_VEC value,
+                       SleqpVec* result);
+
+SLEQP_EXPORT
+const char*
+sleqp_solver_info(const SleqpSolver* solver);
+
+/**
+ * Returns the status of the last call to @ref sleqp_solver_solve
+ *
+ * @param[in]  solver           The solver
+ *
+ **/
+SLEQP_EXPORT SLEQP_STATUS
+sleqp_solver_status(const SleqpSolver* solver);
+
+/**
+ * Resets the solvers internal state
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_reset(SleqpSolver* solver);
+
+/**
+ * Aborts the solver after the next iteration. To be used from callback
+ *functions
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_abort(SleqpSolver* solver);
+
+/**
+ * Returns the current iterate of the solver
+ *
+ * @param[in]  solver           The solver
+ * @param[out] iterate          A pointer to the current iterate
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_solution(SleqpSolver* solver, SleqpIterate** iterate);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_violated_constraints(SleqpSolver* solver,
+                                  SleqpIterate* iterate,
+                                  int* violated_constraints,
+                                  int* num_violated_constraints);
+
+/**
+ * Returns the number of iterations performed during the last call to @ref
+ *sleqp_solver_solve
+ *
+ * @param[in]  solver           The solver
+ *
+ **/
+SLEQP_EXPORT
+int
+sleqp_solver_iterations(const SleqpSolver* solver);
+
+/**
+ * Returns the number of seconds elapsed during the last call to @ref
+ *sleqp_solver_solve
+ *
+ * @param[in]  solver           The solver
+ *
+ **/
+SLEQP_EXPORT
+double
+sleqp_solver_elapsed_seconds(const SleqpSolver* solver);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_add_callback(SleqpSolver* solver,
+                          SLEQP_SOLVER_EVENT solver_event,
+                          void* callback_func,
+                          void* callback_data);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_remove_callback(SleqpSolver* solver,
+                             SLEQP_SOLVER_EVENT solver_event,
+                             void* callback_func,
+                             void* callback_data);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_capture(SleqpSolver* solver);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_solver_release(SleqpSolver** star);
+
+#endif /* SLEQP_PUB_SOLVER_H */

casadi/include/sleqp/pub_types.h

@@ -0,0 +1,230 @@
+#ifndef SLEQP_PUB_TYPES_H
+#define SLEQP_PUB_TYPES_H
+
+/**
+ * @file pub_types.h
+ * @brief Definition of basic types.
+ **/
+
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdio.h>
+
+#include "sleqp/pub_log.h"
+
+#ifdef SLEQP_HAVE_ATTRIBUTE_WARN_UNUSED_RESULT
+#define SLEQP_WARNUNUSED __attribute__((warn_unused_result))
+#else
+#define SLEQP_WARNUNUSED
+#endif
+
+#ifdef SLEQP_HAVE_ATTRIBUTE_NODISCARD
+#define SLEQP_NODISCARD(x) [[nodiscard(x)]]
+#else
+#define SLEQP_NODISCARD(x)
+#endif
+
+typedef enum SLEQP_NODISCARD("error indicator")
+{
+  SLEQP_ERROR      = -1,
+  SLEQP_OKAY       = 0,
+  SLEQP_ABORT_TIME = 1,
+} SLEQP_RETCODE;
+
+typedef enum
+{
+  SLEQP_FAILED_ASSERTION,
+  SLEQP_NOMEM,
+  SLEQP_INTERNAL_ERROR,
+  SLEQP_FUNC_EVAL_ERROR,
+  SLEQP_CALLBACK_ERROR,
+  SLEQP_MATH_ERROR,
+  SLEQP_INVALID_DERIV,
+  SLEQP_ILLEGAL_ARGUMENT
+} SLEQP_ERROR_TYPE;
+
+/**
+ * The state of a variable or constraint with respect
+ * to an active set
+ **/
+typedef enum
+{
+  /** The variable / constraint is inactive **/
+  SLEQP_INACTIVE = 0,
+  /** The variable / constraint is active at its lower bound **/
+  SLEQP_ACTIVE_LOWER = (1 << 0),
+  /** The variable / constraint is active at its upper bound **/
+  SLEQP_ACTIVE_UPPER = (1 << 1),
+  /** The variable / constraint is active at both of its bounds **/
+  SLEQP_ACTIVE_BOTH = (SLEQP_ACTIVE_LOWER | SLEQP_ACTIVE_UPPER),
+} SLEQP_ACTIVE_STATE;
+
+typedef enum
+{
+  SLEQP_STATUS_UNKNOWN = 0,
+  SLEQP_STATUS_RUNNING,
+  SLEQP_STATUS_OPTIMAL,
+  SLEQP_STATUS_INFEASIBLE,
+  SLEQP_STATUS_UNBOUNDED,
+  SLEQP_STATUS_ABORT_DEADPOINT,
+  SLEQP_STATUS_ABORT_ITER,
+  SLEQP_STATUS_ABORT_MANUAL,
+  SLEQP_STATUS_ABORT_TIME
+} SLEQP_STATUS;
+
+#define SLEQP_CALL(x)                                                          \
+  do                                                                           \
+  {                                                                            \
+    const SLEQP_RETCODE _status = (x);                                         \
+    if (_status < SLEQP_OKAY)                                                  \
+    {                                                                          \
+      sleqp_log_error("Error in function %s", __PRETTY_FUNCTION__);            \
+      return _status;                                                          \
+    }                                                                          \
+    else if (_status != SLEQP_OKAY)                                            \
+    {                                                                          \
+      return _status;                                                          \
+    }                                                                          \
+  } while (0)
+
+typedef enum
+{
+  SLEQP_DERIV_CHECK_SKIP       = 0,
+  SLEQP_DERIV_CHECK_FIRST_OBJ  = (1 << 0),
+  SLEQP_DERIV_CHECK_FIRST_CONS = (1 << 1),
+  SLEQP_DERIV_CHECK_FIRST
+    = (SLEQP_DERIV_CHECK_FIRST_OBJ | SLEQP_DERIV_CHECK_FIRST_CONS),
+  SLEQP_DERIV_CHECK_SECOND_SIMPLE = (1 << 2),
+  SLEQP_DERIV_CHECK_SECOND_OBJ    = (1 << 3),
+  SLEQP_DERIV_CHECK_SECOND_CONS   = (1 << 4),
+  SLEQP_DERIV_CHECK_SECOND_EXHAUSTIVE
+    = (SLEQP_DERIV_CHECK_SECOND_OBJ | SLEQP_DERIV_CHECK_SECOND_CONS),
+} SLEQP_DERIV_CHECK;
+
+typedef enum
+{
+  SLEQP_HESS_EVAL_EXACT = 0,
+  SLEQP_HESS_EVAL_SR1,
+  SLEQP_HESS_EVAL_SIMPLE_BFGS,
+  SLEQP_HESS_EVAL_DAMPED_BFGS,
+} SLEQP_HESS_EVAL;
+
+typedef enum
+{
+  SLEQP_BFGS_SIZING_NONE = 0,    // No sizing
+  SLEQP_BFGS_SIZING_CENTERED_OL, // Centered Oren–Luenberger
+} SLEQP_BFGS_SIZING;
+
+typedef enum
+{
+  SLEQP_STEPTYPE_NONE = 0,
+  SLEQP_STEPTYPE_ACCEPTED,
+  SLEQP_STEPTYPE_ACCEPTED_FULL,
+  SLEQP_STEPTYPE_ACCEPTED_SOC,
+  SLEQP_STEPTYPE_REJECTED
+} SLEQP_STEPTYPE;
+
+typedef enum
+{
+  SLEQP_DUAL_ESTIMATION_TYPE_LP,
+  SLEQP_DUAL_ESTIMATION_TYPE_LSQ,
+  SLEQP_DUAL_ESTIMATION_TYPE_MIXED,
+} SLEQP_DUAL_ESTIMATION_TYPE;
+
+typedef enum
+{
+  SLEQP_TR_SOLVER_TRLIB = 0,
+  SLEQP_TR_SOLVER_CG,
+  SLEQP_TR_SOLVER_LSQR,
+  SLEQP_TR_SOLVER_AUTO
+} SLEQP_TR_SOLVER;
+
+typedef enum
+{
+  SLEQP_POLISHING_NONE = 0,
+  SLEQP_POLISHING_ZERO_DUAL,
+  SLEQP_POLISHING_INACTIVE
+} SLEQP_POLISHING_TYPE;
+
+typedef enum
+{
+  SLEQP_PARAMETRIC_CAUCHY_DISABLED = 0,
+  SLEQP_PARAMETRIC_CAUCHY_COARSE,
+  SLEQP_PARAMETRIC_CAUCHY_FINE
+} SLEQP_PARAMETRIC_CAUCHY;
+
+typedef enum
+{
+  SLEQP_INITIAL_TR_CHOICE_NARROW,
+  SLEQP_INITIAL_TR_CHOICE_WIDE
+} SLEQP_INITIAL_TR_CHOICE;
+
+typedef enum
+{
+  SLEQP_LINESEARCH_EXACT,
+  SLEQP_LINESEARCH_APPROX,
+} SLEQP_LINESEARCH;
+
+typedef enum
+{
+  SLEQP_SOLVER_EVENT_ACCEPTED_ITERATE = 0,
+  SLEQP_SOLVER_EVENT_PERFORMED_ITERATION,
+  SLEQP_SOLVER_EVENT_FINISHED,
+  SLEQP_SOLVER_NUM_EVENTS
+} SLEQP_SOLVER_EVENT;
+
+typedef enum
+{
+  SLEQP_PREPROCESSING_RESULT_SUCCESS,
+  SLEQP_PREPROCESSING_RESULT_FAILURE,
+  SLEQP_PREPROCESSING_RESULT_INFEASIBLE
+} SLEQP_PREPROCESSING_RESULT;
+
+typedef enum
+{
+  SLEQP_STEP_RULE_DIRECT,
+  SLEQP_STEP_RULE_WINDOW,
+  SLEQP_STEP_RULE_MINSTEP
+} SLEQP_STEP_RULE;
+
+typedef enum
+{
+  SLEQP_AUG_JAC_AUTO,
+  SLEQP_AUG_JAC_STANDARD,
+  SLEQP_AUG_JAC_REDUCED,
+  SLEQP_AUG_JAC_DIRECT
+} SLEQP_AUG_JAC_METHOD;
+
+typedef enum
+{
+  SLEQP_SOLVER_STATE_REAL_TRUST_RADIUS,
+  SLEQP_SOLVER_STATE_REAL_LP_TRUST_RADIUS,
+  SLEQP_SOLVER_STATE_REAL_SCALED_OBJ_VAL,
+  SLEQP_SOLVER_STATE_REAL_SCALED_MERIT_VAL,
+  SLEQP_SOLVER_STATE_REAL_SCALED_FEAS_RES,
+  SLEQP_SOLVER_STATE_REAL_SCALED_STAT_RES,
+  SLEQP_SOLVER_STATE_REAL_SCALED_SLACK_RES,
+  SLEQP_SOLVER_STATE_REAL_PENALTY_PARAM,
+  SLEQP_SOLVER_STATE_REAL_MIN_RAYLEIGH,
+  SLEQP_SOLVER_STATE_REAL_MAX_RAYLEIGH,
+} SLEQP_SOLVER_STATE_REAL;
+
+typedef enum
+{
+  SLEQP_SOLVER_STATE_INT_LAST_STEP_ON_BDRY,
+  SLEQP_SOLVER_STATE_INT_ITERATION,
+  SLEQP_SOLVER_STATE_INT_LAST_STEP_TYPE,
+} SLEQP_SOLVER_STATE_INT;
+
+typedef enum
+{
+  SLEQP_SOLVER_STATE_VEC_SCALED_STAT_RESIDUALS,
+  SLEQP_SOLVER_STATE_VEC_SCALED_FEAS_RESIDUALS,
+  SLEQP_SOLVER_STATE_VEC_SCALED_CONS_SLACK_RESIDUALS,
+  SLEQP_SOLVER_STATE_VEC_SCALED_VAR_SLACK_RESIDUALS,
+} SLEQP_SOLVER_STATE_VEC;
+
+/**None value to be used in place of integer parameters **/
+#define SLEQP_NONE (-1)
+
+#endif /* SLEQP_PUB_TYPES_H */

casadi/include/sleqp/pub_working_set.h

@@ -0,0 +1,135 @@
+#ifndef SLEQP_PUB_WORKING_SET_H
+#define SLEQP_PUB_WORKING_SET_H
+
+/**
+ * @file pub_working_set.h
+ * @brief Definition of working sets.
+ **/
+
+/**
+ * @defgroup working_set Working sets
+ *
+ * The working set \f$ \workingSet \f$ is a subset of at most
+ * \f$ n \f$ variables / constraints which are active
+ * with respect to the primal point \f$ x \in R^n \f$
+ * and a primal direction \f$ d \in \R^n \f$. The
+ * set of active variables is given as
+ *
+ * \f[
+ *     \{ j \in [n] \mid x_j + d_j \in \{(l_x)_j, (u_x)_j\} \},
+ * \f]
+ *
+ * where a variable \f$ j \f$ can be active at its
+ * lower bound \f$ l_j \f$, it upper bound \f$ u_j \f$,
+ * or at both bounds (if their values coincide).
+ * Activity with respect to constraints is defined
+ * analogously.
+ *
+ * In term of the constraints, each variable
+ * \f$ j \f$ corresponds to the row
+ *
+ * \f[
+ * (l_x)_j \leq \langle e_j, x \rangle \leq (u_x)_j,
+ * \f]
+ *
+ * whereas each constraint \f$ i \in [m] \f$
+ * has the associated row
+ *
+ * \f[
+ * l_i \leq c_i(x) + \langle \nabla c_i(x), x \rangle \leq u_i,
+ * \f]
+ *
+ * The rows corresponding of variables / constraints
+ * in \f$ \workingSet \f$
+ * are guaranteed to be linearly independent.
+ *
+ **/
+
+#include "sleqp/export.h"
+
+#include "sleqp/pub_problem.h"
+
+typedef struct SleqpWorkingSet SleqpWorkingSet;
+
+/**
+ * Creates a new working set corresponding to the given problem
+ *
+ * @param[out] star            A pointer to the working set to be created
+ * @param[int] problem         The underlying problem
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_working_set_create(SleqpWorkingSet** star, SleqpProblem* problem);
+
+/**
+ * Returns the state of the given variable with respect to the given working set
+ *
+ * @param[in]  working_set           The working set
+ * @param[in]  index                 The variable index
+ **/
+SLEQP_EXPORT SLEQP_ACTIVE_STATE
+sleqp_working_set_var_state(const SleqpWorkingSet* working_set, int index);
+
+/**
+ * Returns the state of the given constraint with respect to the given working
+ * set
+ *
+ * @param[in]  working_set           The working set
+ * @param[in]  index                 The constraint index
+ **/
+SLEQP_EXPORT SLEQP_ACTIVE_STATE
+sleqp_working_set_cons_state(const SleqpWorkingSet* working_set, int index);
+
+/**
+ * Returns an array containing the states of all variables with respect to the
+ * given working set
+ **/
+SLEQP_EXPORT const SLEQP_ACTIVE_STATE*
+sleqp_working_set_var_states(const SleqpWorkingSet* working_set);
+
+/**
+ * Returns an array containing the states of all constraints with respect to the
+ * given working set
+ **/
+SLEQP_EXPORT const SLEQP_ACTIVE_STATE*
+sleqp_working_set_cons_states(const SleqpWorkingSet* working_set);
+
+/**
+ * Returns the problem underling the given working set
+ *
+ * @param[in]  working_set           The working set
+ **/
+SLEQP_EXPORT SleqpProblem*
+sleqp_working_set_problem(const SleqpWorkingSet* working_set);
+
+/**
+ * Returns the number of variables contained in the given working set
+ *
+ * @param[in]  working_set           The working set
+ **/
+SLEQP_EXPORT int
+sleqp_working_set_num_active_vars(const SleqpWorkingSet* working_set);
+
+/**
+ * Returns the number of constraints contained in the given working set
+ *
+ * @param[in]  working_set           The working set
+ **/
+SLEQP_EXPORT int
+sleqp_working_set_num_active_cons(const SleqpWorkingSet* working_set);
+
+/**
+ * Returns the size of the given set, i.e. the number of contained variables
+ *plus the number of contained constraints
+ *
+ * @param[in]  working_set           The working set
+ **/
+SLEQP_EXPORT int
+sleqp_working_set_size(const SleqpWorkingSet* working_set);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_working_set_capture(SleqpWorkingSet* working_set);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_working_set_release(SleqpWorkingSet** star);
+
+#endif /* SLEQP_PUB_WORKING_SET_H */