casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

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

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