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

casadi/include/sleqp/pub_log.h

@@ -0,0 +1,88 @@
+#ifndef SLEQP_PUB_LOG_H
+#define SLEQP_PUB_LOG_H
+
+/**
+ * @file pub_log.h
+ * @brief Logging functionality.
+ **/
+
+#include <time.h>
+
+#include "sleqp/defs.h"
+#include "sleqp/export.h"
+
+/**
+ * Definition of log levels
+ **/
+typedef enum
+{
+  SLEQP_LOG_SILENT     = 0,
+  SLEQP_LOG_ERROR      = 1,
+  SLEQP_LOG_WARN       = 2,
+  SLEQP_LOG_INFO       = 3,
+  SLEQP_LOG_DEBUG      = 4,
+  SLEQP_NUM_LOG_LEVELS = 5
+} SLEQP_LOG_LEVEL;
+
+/**
+ * Returns the current log level
+ **/
+SLEQP_EXPORT SLEQP_LOG_LEVEL
+sleqp_log_level();
+
+/**
+ * Sets the log level
+ **/
+SLEQP_EXPORT void
+sleqp_log_set_level(SLEQP_LOG_LEVEL level);
+
+/**
+ * Definition of the log handler function
+ **/
+typedef void (*SLEQP_LOG_HANDLER)(SLEQP_LOG_LEVEL level,
+                                  time_t time,
+                                  const char* message);
+
+/**
+ * Sets a custom log handler
+ **/
+SLEQP_EXPORT void
+sleqp_log_set_handler(SLEQP_LOG_HANDLER handler);
+
+SLEQP_EXPORT void
+sleqp_log_msg_level(int level, const char* fmt, ...) SLEQP_FORMAT_PRINTF(2, 3);
+
+void
+sleqp_log_trace_level(int level,
+                      const char* file,
+                      int line,
+                      const char* fmt,
+                      ...) SLEQP_FORMAT_PRINTF(4, 5);
+
+#define sleqp_bool_string(x) ((x) ? "true" : "false")
+
+#define sleqp_log_log_trace(level, file, line, ...)                            \
+  do                                                                           \
+  {                                                                            \
+    if (sleqp_log_level() >= level)                                            \
+    {                                                                          \
+      sleqp_log_trace_level(level, file, line, __VA_ARGS__);                   \
+    }                                                                          \
+  } while (0)
+
+#define sleqp_log_log_msg(level, ...)                                          \
+  do                                                                           \
+  {                                                                            \
+    if (sleqp_log_level() >= level)                                            \
+    {                                                                          \
+      sleqp_log_msg_level(level, __VA_ARGS__);                                 \
+    }                                                                          \
+  } while (0)
+
+#define sleqp_log_info(...) sleqp_log_log_msg(SLEQP_LOG_INFO, __VA_ARGS__)
+#define sleqp_log_warn(...) sleqp_log_log_msg(SLEQP_LOG_WARN, __VA_ARGS__)
+#define sleqp_log_error(...) sleqp_log_log_msg(SLEQP_LOG_ERROR, __VA_ARGS__)
+
+#define sleqp_log_debug(...) sleqp_log_log_msg(SLEQP_LOG_DEBUG, __VA_ARGS__)
+
+#endif /* SLEQP_PUB_LOG_H */

casadi/include/sleqp/pub_lsq.h

@@ -0,0 +1,158 @@
+#ifndef SLEQP_PUB_LSQ_H
+#define SLEQP_PUB_LSQ_H
+
+/**
+ * @file pub_lsq.h
+ * @brief Defintion of least squares functions.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_iterate.h"
+#include "sleqp/pub_problem.h"
+#include "sleqp/sparse/pub_vec.h"
+
+/**
+ * @defgroup least_squares Nonlinear least-squares problems
+ *
+ * A least-squares function is defined in terms of residuals
+ * \f$ r : \R^n \to \R^k \f$
+ *
+ * yielding the objective
+ *
+ * \f[
+ *     f(x) := \frac{1}{2} \|r(x)\|^2
+ * \f]
+ *
+ * subjecting to the usual constraints. During the optimization, the
+ * Hessian being used is not that of the original Lagrangean, but
+ * instead the Levenberg-Marquardt approximation of the Hessian of the
+ * objective \f$ f \f$, given as
+ *
+ * \f[
+ * H_f(x) \approx J^{T}(x) \cdot J(x).
+ * \f]
+ *
+ * Optionally, the user can provide a regularization
+ * factor \f$ \lmfact > 0 \f$, which will add a term
+ * of \f$ \lmfact \cdot I_{n} \f$ to the Hessian.
+ **/
+
+/**
+ * Queries the number of nonzeros of the function at the
+ * current primal point.
+ *
+ * @param[in]     func            The function
+ * @param[out]    residual_nnz    The number of nonzeros of the residuals
+ *\f$r(x)\f$
+ * @param[out]    jac_fwd_nnz     The number of nonzeros of
+ *\f$J_r(x)d\f$
+ * @param[out]    jac_adj_nnz     The number of nonzeros of
+ *\f$d^{T}J_r(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
+ **/
+typedef SLEQP_RETCODE (*SLEQP_LSQ_NONZEROS)(SleqpFunc* func,
+                                            int* residual_nnz,
+                                            int* jac_fwd_nnz,
+                                            int* jac_adj_nnz,
+                                            int* cons_val_nnz,
+                                            int* cons_jac_nnz,
+                                            void* func_data);
+
+/**
+ * Evaluates the residuals \f$ r(x) \f$ at the current primal point.
+ *
+ * @param[in]     func              The function
+ * @param[out]    residual          The resulting residual
+ * @param[in,out] func_data         The function data
+ *
+ */
+typedef SLEQP_RETCODE (*SLEQP_LSQ_RESIDUALS)(SleqpFunc* func,
+                                             SleqpVec* residual,
+                                             void* func_data);
+
+/**
+ * Evaluates the forward product of the Jacobian of the residuals at the
+ * current primal point \f$ J_r(x) \f$ with a direction
+ * \f$ d \in \R^n \f$.
+ *
+ * @param[in]     func              The function
+ * @param[in]     forward_direction The direction \f$ d \f$
+ * @param[out]    product           The resulting product
+ * @param[in,out] func_data         The function data
+ *
+ */
+typedef SLEQP_RETCODE (*SLEQP_LSQ_JAC_FORWARD)(
+  SleqpFunc* func,
+  const SleqpVec* forward_direction,
+  SleqpVec* product,
+  void* func_data);
+
+/**
+ * Evaluates the adjoint product of the Jacobian of the residuals at the
+ * current primal point \f$ J_r(x) \f$ with a
+ * direction \f$ d \in \R^k \f$.
+ *
+ * @param[in]     func              The function
+ * @param[in]     adjoint_direction The direction \f$ d \f$
+ * @param[out]    product           The resulting product
+ * @param[in,out] func_data         The function data
+ *
+ */
+typedef SLEQP_RETCODE (*SLEQP_LSQ_JAC_ADJOINT)(
+  SleqpFunc* func,
+  const SleqpVec* adjoint_direction,
+  SleqpVec* product,
+  void* func_data);
+
+typedef struct
+{
+  SLEQP_FUNC_SET set_value;
+  SLEQP_LSQ_NONZEROS lsq_nonzeros;
+  SLEQP_LSQ_RESIDUALS lsq_residuals;
+  SLEQP_LSQ_JAC_FORWARD lsq_jac_forward;
+  SLEQP_LSQ_JAC_ADJOINT lsq_jac_adjoint;
+  SLEQP_FUNC_CONS_VAL cons_val;
+  SLEQP_FUNC_CONS_JAC cons_jac;
+  SLEQP_FUNC_FREE func_free;
+} SleqpLSQCallbacks;
+
+/**
+ * Creates a least-squares function.
+ *
+ * @param[out] fstar           A pointer to the function to be created
+ * @param[in]  callbacks       Required callbacks
+ * @param[in]  num_variables   The number \f$ n \f$ of variables
+ * @param[in]  num_constraints The number \f$ m \f$ of constraints
+ * @param[in]  num_residuals   The number \f$ k \f$ of residuals
+ * @param[in]  lm_factor       The regularization factor \f$ \lmfact \f$
+ * @param[in]  params          Numerical parameters
+ * @param[in]  func_data       User-provided function data
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_lsq_func_create(SleqpFunc** fstar,
+                      SleqpLSQCallbacks* callbacks,
+                      int num_variables,
+                      int num_constraints,
+                      int num_residuals,
+                      double lm_factor,
+                      SleqpSettings* settings,
+                      void* func_data);
+
+/**
+ * Sets the callbacks of this LSQ function to the specified ones
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_lsq_func_set_callbacks(SleqpFunc* func, SleqpLSQCallbacks* callbacks);
+
+/**
+ * Sets the regularization factor \f$ \lmfact \f$
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_lsq_func_set_lm_factor(SleqpFunc* func, double lm_factor);
+
+#endif /* SLEQP_PUB_LSQ_H */

casadi/include/sleqp/pub_mem.h

@@ -0,0 +1,52 @@
+#ifndef SLEQP_PUB_MEM_H
+#define SLEQP_PUB_MEM_H
+
+/**
+ * @file pub_mem.h
+ * @brief Definition of memory (de-)allocation functions.
+ **/
+
+#include <stdlib.h>
+
+#include "pub_error.h"
+#include "pub_types.h"
+
+#define sleqp_allocate_memory(ptr, size)                                       \
+  (*(ptr) = ((size) > 0) ? malloc((size)) : NULL),                             \
+    (((size) > 0) && (*(ptr) == NULL))                                         \
+      ? (sleqp_set_error(__FILE__,                                             \
+                         __LINE__,                                             \
+                         __PRETTY_FUNCTION__,                                  \
+                         SLEQP_NOMEM,                                          \
+                         "Failed to allocate %ld bytes of memory",             \
+                         size),                                                \
+         SLEQP_ERROR)                                                          \
+      : SLEQP_OKAY
+
+#define sleqp_reallocate_memory(ptr, size)                                     \
+  (*ptr = realloc(*ptr, size), (((size) > 0) && (*(ptr) == NULL)))             \
+    ? (sleqp_set_error(__FILE__,                                               \
+                       __LINE__,                                               \
+                       __PRETTY_FUNCTION__,                                    \
+                       SLEQP_NOMEM,                                            \
+                       "Failed to allocate %ld bytes of memory",               \
+                       size),                                                  \
+       SLEQP_ERROR)                                                            \
+    : SLEQP_OKAY
+
+SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_free(void** ptr);
+
+#define sleqp_malloc(ptr) sleqp_allocate_memory(ptr, sizeof(**ptr))
+
+#define sleqp_alloc_array(ptr, count)                                          \
+  sleqp_allocate_memory(ptr, ((count) * sizeof(**ptr)))
+
+#define sleqp_realloc(ptr, count)                                              \
+  sleqp_reallocate_memory(ptr, ((count) * sizeof(**ptr)))
+
+#define sleqp_free(ptr)                                                        \
+  free(*ptr);                                                                  \
+  *ptr = NULL
+
+#endif /* SLEQP_PUB_MEM_H */

casadi/include/sleqp/pub_problem.h

@@ -0,0 +1,213 @@
+#ifndef SLEQP_PUB_PROBLEM_H
+#define SLEQP_PUB_PROBLEM_H
+
+#include "sleqp/export.h"
+
+#include "sleqp/pub_func.h"
+#include "sleqp/pub_settings.h"
+#include "sparse/pub_mat.h"
+#include "sparse/pub_vec.h"
+
+/**
+ * @file pub_problem.h
+ * @brief Definition of the programming problem.
+ **/
+
+/**
+ * @defgroup problem Nonlinear programming problems
+ *
+ * An NLP is given as
+ *
+ * \f[
+ * \begin{aligned}
+ * \min \: & f(x)                       \\
+ * \st \: & l \leq c(x) \leq u \\
+ * & l_x \leq x \leq u_x
+ * \end{aligned}
+ * \f]
+ *
+ * where \f$ f : \R^{n} \to \R \f$,
+ * \f$ c : \R^{n} \to \R^{m} \f$
+ * are functions, \f$ l, u \in \R^{m}, l \leq u \f$
+ * are the constraint bounds, and
+ * \f$ l_x, u_x \in \R^{n}, l_x \leq u_x \f$
+ * are the variable bounds.
+ *
+ * The constraints \f$ c\f$ can optionally be split up into general
+ * nonlinear constraints
+ * \f$ c_{\nonlin} : \R^{n} \to \R^{m_{\nonlin}} \f$
+ * and linear coefficients \f$ A \in \R^{m_{\lin} \times n}\f$.
+ * Consequently, the lower and upper bounds \f$ l, u \f$ are split up
+ * into \f$ l_{\nonlin}, u_{\nonlin} \in \R^{m_{\nonlin}} \f$ and
+ * \f$ l_{\lin}, u_{\lin} \in \R^{m_{\lin}} \f$
+ * The constraints \f$ c \f$ are then given as
+ *
+ * \f[
+ *   c(x) = \left( c_{\nonlin}(x), A \cdot x \right).
+ * \f]
+ *
+ * @see function
+ *
+ * @{
+ **/
+
+typedef struct SleqpProblem SleqpProblem;
+
+/**
+ * Creates a new problem without linear coefficients.
+ *
+ * @param[in] func        The function associated with the problem
+ * @param[in] var_lb      The lower variable bounds \f$ l_x \f$
+ * @param[in] var_ub      The upper variable bounds \f$ u_x \f$
+ * @param[in] general_lb  The lower bounds \f$ l \f$ on the constraints
+ * @param[in] general_ub  The upper bounds \f$ u \f$ on the constraints
+ * @param[in] settings    Settings (`NULL` for default settings)
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_problem_create_simple(SleqpProblem** star,
+                            SleqpFunc* func,
+                            const SleqpVec* var_lb,
+                            const SleqpVec* var_ub,
+                            const SleqpVec* general_lb,
+                            const SleqpVec* general_ub,
+                            SleqpSettings* settings);
+
+/**
+ * Creates a new problem with linear coefficients.
+ *
+ * @param[in] func        The function associated with the problem
+ * @param[in] var_lb      The lower variable bounds \f$ l_x \f$
+ * @param[in] var_ub      The upper variable bounds \f$ u_x \f$
+ * @param[in] general_lb  The lower bounds \f$ l_{\nonlin} \f$ on the
+ *constraints
+ * @param[in] general_ub  The upper bounds \f$ u_{\nonlin} \f$ on the
+ *constraints
+ * @param[in] linear_coeffs The linear coefficient matrix \f$ A \f$
+ * @param[in] linear_lb  The lower bounds \f$ l_{\lin} \f$ on the
+ *constraints
+ * @param[in] linear_ub  The upper bounds \f$ u_{\lin} \f$ on the
+ *constraints
+ * @param[in] settings    Settings (`NULL` for default settings)
+ *
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_problem_create(SleqpProblem** star,
+                     SleqpFunc* func,
+                     const SleqpVec* var_lb,
+                     const SleqpVec* var_ub,
+                     const SleqpVec* genereal_lb,
+                     const SleqpVec* genereal_ub,
+                     const SleqpMat* linear_coeffs,
+                     const SleqpVec* linear_lb,
+                     const SleqpVec* linear_ub,
+                     SleqpSettings* settings);
+
+/**
+ * Returns the total number \f$ m \f$ of constraints (both general and
+ * linear) of the problem.
+ **/
+SLEQP_EXPORT int
+sleqp_problem_num_cons(const SleqpProblem* problem);
+
+/**
+ * Returns the total number \f$ m_{\lin} \f$ of linear constraints of
+ * the problem.
+ **/
+SLEQP_EXPORT int
+sleqp_problem_num_lin_cons(const SleqpProblem* problem);
+
+/**
+ * Returns the total number \f$ m_{\nonlin} \f$ of general constraints
+ * of the problem.
+ **/
+SLEQP_EXPORT int
+sleqp_problem_num_gen_cons(const SleqpProblem* problem);
+
+/**
+ * Returns the function, composed of the objective \f$ f \f$ and the
+ * general constraints \f$ c_{\nonlin} \f$ associated with the
+ * problem.
+ **/
+SLEQP_EXPORT SleqpFunc*
+sleqp_problem_func(SleqpProblem* problem);
+
+/**
+ * Returns the number \f$ n \f$ of variables of the problem.
+ **/
+SLEQP_EXPORT int
+sleqp_problem_num_vars(const SleqpProblem* problem);
+
+/**
+ * Returns the lower bounds \f$ l_x \f$ of the variables
+ * with respect to the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_vars_lb(SleqpProblem* problem);
+
+/**
+ * Returns the lower bounds \f$ u_x \f$ of the variables
+ * with respect to the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_vars_ub(SleqpProblem* problem);
+
+/**
+ * Returns the lower bounds \f$ l_{\nonlin} \f$ of the general
+ * constraints \f$ c_{\nonlin} \f$ of the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_general_lb(SleqpProblem* problem);
+
+/**
+ * Returns the upper bounds \f$ l_{\nonlin} \f$ of the general
+ * constraints \f$ c_{\nonlin} \f$ of the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_general_ub(SleqpProblem* problem);
+
+/**
+ * Returns the linear coefficient matrix \f$ A \f$ of the problem.
+ **/
+SLEQP_EXPORT SleqpMat*
+sleqp_problem_linear_coeffs(SleqpProblem* problem);
+
+/**
+ * Returns the upper bounds \f$ l_{\lin} \f$ of the linear
+ * constraints of the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_linear_lb(SleqpProblem* problem);
+
+/**
+ * Returns the upper bounds \f$ u_{\lin} \f$ of the linear
+ * constraints of the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_linear_ub(SleqpProblem* problem);
+
+/**
+ * Returns the lower bounds \f$ l \f$ of the
+ * constraints \f$ c \f$ of the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_cons_lb(SleqpProblem* problem);
+
+/**
+ * Returns the upper bounds \f$ u \f$ of the
+ * constraints \f$ c \f$ of the problem.
+ **/
+SLEQP_EXPORT SleqpVec*
+sleqp_problem_cons_ub(SleqpProblem* problem);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_problem_capture(SleqpProblem* problem);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_problem_release(SleqpProblem** star);
+
+/**
+ * @}
+ **/
+
+#endif /* SLEQP_PUB_PROBLEM_H */

casadi/include/sleqp/pub_scale.h

@@ -0,0 +1,150 @@
+#ifndef SLEQP_PUB_SCALE_H
+#define SLEQP_PUB_SCALE_H
+
+/**
+ * @file pub_scale.h
+ * @brief Definition of the problem scaling.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_iterate.h"
+#include "sleqp/pub_problem.h"
+
+/**
+ * @defgroup scaling NLP scaling
+ *
+ * The scaled version of the basic NLP is given by
+ *
+ * \f[
+ * \begin{aligned}
+ * \min \: & f'(x')                \\
+ * \st \: & l' \leq c'(x') \leq u' \\
+ * & l'_x \leq x' \leq u'_x,
+ * \end{aligned}
+ * \f]
+ *
+ * defined by scaling weights \f$ \lambda \in \mathbb{Z} \f$,
+ * \f$ \alpha \in \mathbb{Z}^{m} \f$,
+ * \f$ \beta \in \mathbb{Z}^{n} \f$.
+ *
+ * The weights \f$ \alpha, \beta \f$ yield scaling
+ * factors \f$ a, b \f$:
+ *
+ * \f[
+ * \begin{aligned}
+ * a_i := 2^{\alpha_i}      \\
+ * b_i := 2^{\beta_i}       \\
+ * \end{aligned}
+ * \f]
+ *
+ * The constraint scales \f$ a \f$ and variable scales
+ * \f$ b \f$ yield matrices
+ * \f$ A = \operatorname{diag}(a) \f$,
+ * \f$ B = \operatorname{diag}(b) \f$.
+ *
+ * \f[
+ * \begin{aligned}
+ * f'(\cdot) &:= 2^{\lambda} f(B \cdot)  \\
+ * c'(\cdot) &:= A c(B \cdot)            \\
+ * l' &:= A l                            \\
+ * u' &:= A u                            \\
+ * l_x' &:= B l_x                        \\
+ * x'   &:= B x                          \\
+ * u_x' &:= B u_x                        \\
+ * \end{aligned}
+ * \f]
+ *
+ * Note that the scaling is exact (apart from over- / underflows)
+ * in the sense that the unscaling is inverse to the scaling
+ * even on floating points.
+ *
+ * In terms of least-squares functions, the objective scaling works
+ * by scaling the residual vector \f$ r(x) \f$ by \f$ 2^{\lambda} \f$.
+ * Consequently, the objective value is scaled by \f$ \approx 2^{2 \lambda} \f$.
+ *
+ * @see Functions
+ *
+ *
+ * @{
+ **/
+
+typedef struct SleqpScaling SleqpScaling;
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_create(SleqpScaling** scaling,
+                     int num_variables,
+                     int num_constraints);
+
+SLEQP_RETCODE
+sleqp_scaling_reset(SleqpScaling* scaling);
+
+SLEQP_EXPORT int
+sleqp_scaling_num_vars(const SleqpScaling* scaling);
+SLEQP_EXPORT int
+sleqp_scaling_num_cons(const SleqpScaling* scaling);
+
+SLEQP_EXPORT int
+sleqp_scaling_obj_weight(const SleqpScaling* scaling);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_obj_weight(SleqpScaling* scaling, int weight);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_obj_weight_from_nominal(SleqpScaling* scaling,
+                                          double nominal_value);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_var_weight(SleqpScaling* scaling, int index, int weight);
+
+/**
+ * Sets variable scaling weights in order for the scaling of the primal values
+ * to map all of the given nominal values to [.5, 1.)
+ **/
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_var_weights_from_nominal(SleqpScaling* scaling,
+                                           double* nominal_values);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_var_weight_from_nominal(SleqpScaling* scaling,
+                                          int index,
+                                          double nominal_value);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_cons_weight(SleqpScaling* scaling, int index, int weight);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_cons_weights_from_nominal(SleqpScaling* scaling,
+                                            double* nominal_values);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_set_cons_weight_from_nominal(SleqpScaling* scaling,
+                                           int index,
+                                           double nominal_value);
+
+SLEQP_EXPORT int*
+sleqp_scaling_var_weights(SleqpScaling* scaling);
+
+SLEQP_EXPORT int*
+sleqp_scaling_cons_weights(SleqpScaling* scaling);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_obj_scaling_from_grad(SleqpScaling* scaling,
+                            SleqpVec* gradient,
+                            double eps);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_from_cons_jac(SleqpScaling* scaling,
+                            SleqpMat* cons_jac,
+                            double eps);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_capture(SleqpScaling* scaling);
+
+SLEQP_EXPORT SLEQP_WARNUNUSED SLEQP_RETCODE
+sleqp_scaling_release(SleqpScaling** star);
+
+/**
+ * @}
+ **/
+
+#endif /* SLEQP_PUB_SCALE_H */