casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

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 */

casadi/include/sleqp/sparse/pub_mat.h

@@ -0,0 +1,153 @@
+#ifndef SLEQP_PUB_MAT_H
+#define SLEQP_PUB_MAT_H
+
+/**
+ * @file pub_mat.h
+ * @brief Definition of sparse matrices.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+#include "sleqp/sparse/pub_vec.h"
+
+/**
+ * A sparse matrix data structure.
+ * So far the data is stored in CSC format.
+ * Specifically:
+ *
+ * \f$ A(i, j) = data[k]\f$ iff \f$ rows[k] = i \f$ and \f$ cols[j] <= k <
+ *cols[j + 1] \f$
+ *
+ * for \f$ k = 0, \ldots, nnz - 1 \f$
+ *
+ **/
+typedef struct SleqpMat SleqpMat;
+
+/**
+ * Creates a new sparse matrix with a specified number of nonzeros
+ *
+ * @param[in] matrix     A pointer to the matrix to be created
+ * @param[in] num_rows   The desired number of rows
+ * @param[in] num_cols   The desired number of columns
+ * @param[in] nnz_max    The desired number of nonzeros
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_create(SleqpMat** matrix, int num_rows, int num_cols, int nnz_max);
+
+/**
+ * Reserves a number of nonzeros for the given matrix
+ *
+ * @param[in] matrix   The matrix
+ * @param[in] nnz      The desired number of nonzeros
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_reserve(SleqpMat* matrix, int nnz);
+
+/**
+ * Resizes the given matrix
+ *
+ * @note If the matrix is non-empty, decreasing the size can leave the matrix in
+ *an inconsistent state
+ *
+ * @param[in] matrix     The matrix
+ * @param[in] num_rows   The desired number of rows
+ * @param[in] num_cols   The desired number of columns
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_resize(SleqpMat* matrix, int num_rows, int num_cols);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_scale(SleqpMat* matrix, double scale);
+
+/**
+ * Returns the number of columns of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_num_cols(const SleqpMat* matrix);
+
+/**
+ * Returns the number of rows of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_num_rows(const SleqpMat* matrix);
+
+/**
+ * Returns the number of nonzeros of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_nnz(const SleqpMat* matrix);
+
+/**
+ * Returns the maximum number of nonzeros of the given matrix
+ **/
+SLEQP_EXPORT int
+sleqp_mat_nnz_max(const SleqpMat* matrix);
+
+/**
+ * Sets the number of nonzeros of the given matrix
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_set_nnz(SleqpMat* matrix, int nnz);
+
+/**
+ * Returns whether the given matrix is rectangular
+ **/
+SLEQP_EXPORT bool
+sleqp_mat_is_quadratic(const SleqpMat* matrix);
+
+/**
+ * Returns a pointer to the values of the matrix
+ **/
+SLEQP_EXPORT double*
+sleqp_mat_data(const SleqpMat* matrix);
+
+/**
+ * Returns a pointer to the columns of the given matrix
+ **/
+SLEQP_EXPORT int*
+sleqp_mat_cols(const SleqpMat* matrix);
+
+/**
+ * Returns a pointer to the rows of the given matrix
+ **/
+SLEQP_EXPORT int*
+sleqp_mat_rows(const SleqpMat* matrix);
+
+/**
+ * Pushes a new entry to the matrix. Fails if the matrix is at capacity
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_push(SleqpMat* matrix, int row, int col, double value);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_push_vec(SleqpMat* matrix, int col, SleqpVec* vec);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_push_col(SleqpMat* matrix, int col);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_pop_col(SleqpMat* matrix, int col);
+
+/**
+ * Copies the given matrix
+ *
+ * @param[in]     source     The source matrix
+ * @param[in,out] target     The target matrix
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_copy(const SleqpMat* source, SleqpMat* target);
+
+/**
+ * Increases the reference count of the given matrix
+ */
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_capture(SleqpMat* matrix);
+
+/**
+ * Decreases the reference count of the given matrix, freeing it
+ * if the reference count reaches count
+ */
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_mat_release(SleqpMat** star);
+
+#endif /* SLEQP_PUB_MAT_H */