casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/qdldl/qdldl.h

@@ -0,0 +1,169 @@
+#ifndef QDLDL_H
+#define QDLDL_H
+
+// Include qdldl type options
+#include "qdldl_types.h"
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+/**
+  * Compute the elimination tree for a quasidefinite matrix
+  * in compressed sparse column form, where the input matrix is
+  * assumed to contain data for the upper triangular part of A only,
+  * and there are no duplicate indices.
+  *
+  * Returns an elimination tree for the factorization A = LDL^T and a
+  * count of the nonzeros in each column of L that are strictly below the
+  * diagonal.
+  *
+  * Does not use MALLOC.  It is assumed that the arrays work, Lnz, and
+  * etree will be allocated with a number of elements equal to n.
+  *
+  * The data in (n,Ap,Ai) are from a square matrix A in CSC format, and
+  * should include the upper triangular part of A only.
+  *
+  * This function is only intended for factorisation of QD matrices specified
+  * by their upper triangular part.  An error is returned if any column has
+  * data below the diagonal or s completely empty.
+  *
+  * For matrices with a non-empty column but a zero on the corresponding diagonal,
+  * this function will *not* return an error, as it may still be possible to factor
+  * such a matrix in LDL form.   No promises are made in this case though...
+  *
+  * @param  n      number of columns in CSC matrix A (assumed square)
+  * @param  Ap     column pointers (size n+1) for columns of A
+  * @param  Ai     row indices of A.  Has Ap[n] elements
+  * @param  work   work vector (size n) (no meaning on return)
+  * @param  Lnz    count of nonzeros in each column of L (size n) below diagonal
+  * @param  etree  elimination tree (size n)
+  * @return total  sum of Lnz (i.e. total nonzeros in L below diagonal).
+  *                Returns -1 if the input is not triu or has an empty column.
+  *                Returns -2 if the return value overflows QDLDL_int.
+  *
+*/
+ QDLDL_int QDLDL_etree(const QDLDL_int   n,
+                       const QDLDL_int* Ap,
+                       const QDLDL_int* Ai,
+                       QDLDL_int* work,
+                       QDLDL_int* Lnz,
+                       QDLDL_int* etree);
+
+
+/**
+  * Compute an LDL decomposition for a quasidefinite matrix
+  * in compressed sparse column form, where the input matrix is
+  * assumed to contain data for the upper triangular part of A only,
+  * and there are no duplicate indices.
+  *
+  * Returns factors L, D and Dinv = 1./D.
+  *
+  * Does not use MALLOC.  It is assumed that L will be a compressed
+  * sparse column matrix with data (n,Lp,Li,Lx)  with sufficient space
+  * allocated, with a number of nonzeros equal to the count given
+  * as a return value by QDLDL_etree
+  *
+  * @param  n      number of columns in L and A (both square)
+  * @param  Ap     column pointers (size n+1) for columns of A (not modified)
+  * @param  Ai     row indices of A.  Has Ap[n] elements (not modified)
+  * @param  Ax     data of A.  Has Ap[n] elements (not modified)
+  * @param  Lp     column pointers (size n+1) for columns of L
+  * @param  Li     row indices of L.  Has Lp[n] elements
+  * @param  Lx     data of L.  Has Lp[n] elements
+  * @param  D      vectorized factor D.  Length is n
+  * @param  Dinv   reciprocal of D.  Length is n
+  * @param  Lnz    count of nonzeros in each column of L below diagonal,
+  *                as given by QDLDL_etree (not modified)
+  * @param  etree  elimination tree as as given by QDLDL_etree (not modified)
+  * @param  bwork  working array of bools. Length is n
+  * @param  iwork  working array of integers. Length is 3*n
+  * @param  fwork  working array of floats. Length is n
+  * @return        Returns a count of the number of positive elements
+  *                in D.  Returns -1 and exits immediately if any element
+  *                of D evaluates exactly to zero (matrix is not quasidefinite
+  *                or otherwise LDL factorisable)
+  *
+*/
+QDLDL_int QDLDL_factor(const QDLDL_int    n,
+                  const QDLDL_int*   Ap,
+                  const QDLDL_int*   Ai,
+                  const QDLDL_float* Ax,
+                  QDLDL_int*   Lp,
+                  QDLDL_int*   Li,
+                  QDLDL_float* Lx,
+                  QDLDL_float* D,
+                  QDLDL_float* Dinv,
+                  const QDLDL_int* Lnz,
+                  const QDLDL_int* etree,
+                  QDLDL_bool* bwork,
+                  QDLDL_int* iwork,
+                  QDLDL_float* fwork);
+
+
+/**
+  * Solves LDL'x = b
+  *
+  * It is assumed that L will be a compressed
+  * sparse column matrix with data (n,Lp,Li,Lx).
+  *
+  * @param  n      number of columns in L
+  * @param  Lp     column pointers (size n+1) for columns of L
+  * @param  Li     row indices of L.  Has Lp[n] elements
+  * @param  Lx     data of L.  Has Lp[n] elements
+  * @param  Dinv   reciprocal of D.  Length is n
+  * @param  x      initialized to b.  Equal to x on return
+  *
+*/
+void QDLDL_solve(const QDLDL_int    n,
+                 const QDLDL_int*   Lp,
+                 const QDLDL_int*   Li,
+                 const QDLDL_float* Lx,
+                 const QDLDL_float* Dinv,
+                 QDLDL_float* x);
+
+
+/**
+ * Solves (L+I)x = b
+ *
+ * It is assumed that L will be a compressed
+ * sparse column matrix with data (n,Lp,Li,Lx).
+ *
+ * @param  n      number of columns in L
+ * @param  Lp     column pointers (size n+1) for columns of L
+ * @param  Li     row indices of L.  Has Lp[n] elements
+ * @param  Lx     data of L.  Has Lp[n] elements
+ * @param  x      initialized to b.  Equal to x on return
+ *
+*/
+void QDLDL_Lsolve(const QDLDL_int    n,
+                  const QDLDL_int*   Lp,
+                  const QDLDL_int*   Li,
+                  const QDLDL_float* Lx,
+                  QDLDL_float* x);
+
+
+/**
+ * Solves (L+I)'x = b
+ *
+ * It is assumed that L will be a compressed
+ * sparse column matrix with data (n,Lp,Li,Lx).
+ *
+ * @param  n      number of columns in L
+ * @param  Lp     column pointers (size n+1) for columns of L
+ * @param  Li     row indices of L.  Has Lp[n] elements
+ * @param  Lx     data of L.  Has Lp[n] elements
+ * @param  x      initialized to b.  Equal to x on return
+ *
+*/
+void QDLDL_Ltsolve(const QDLDL_int    n,
+                   const QDLDL_int*   Lp,
+                   const QDLDL_int*   Li,
+                   const QDLDL_float* Lx,
+                   QDLDL_float* x);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif // ifndef QDLDL_H

casadi/include/qdldl/qdldl_types.h

@@ -0,0 +1,23 @@
+#ifndef QDLDL_TYPES_H
+# define QDLDL_TYPES_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif /* ifdef __cplusplus */
+
+#include <limits.h> //for the QDLDL_INT_TYPE_MAX
+
+// QDLDL integer and float types
+
+typedef long long    QDLDL_int;   /* for indices */
+typedef double  QDLDL_float; /* for numerical values  */
+typedef unsigned char   QDLDL_bool;  /* for boolean values  */
+
+//Maximum value of the signed type QDLDL_int.
+#define QDLDL_INT_MAX LLONG_MAX
+
+# ifdef __cplusplus
+}
+# endif /* ifdef __cplusplus */
+
+#endif /* ifndef QDLDL_TYPES_H */

casadi/include/s_blas.h

@@ -0,0 +1,78 @@
+/**************************************************************************************************
+*                                                                                                 *
+* This file is part of BLASFEO.                                                                   *
+*                                                                                                 *
+* BLASFEO -- BLAS For Embedded Optimization.                                                      *
+* Copyright (C) 2019 by Gianluca Frison.                                                          *
+* Developed at IMTEK (University of Freiburg) under the supervision of Moritz Diehl.              *
+* All rights reserved.                                                                            *
+*                                                                                                 *
+* The 2-Clause BSD License                                                                        *
+*                                                                                                 *
+* Redistribution and use in source and binary forms, with or without                              *
+* modification, are permitted provided that the following conditions are met:                     *
+*                                                                                                 *
+* 1. Redistributions of source code must retain the above copyright notice, this                  *
+*    list of conditions and the following disclaimer.                                             *
+* 2. Redistributions in binary form must reproduce the above copyright notice,                    *
+*    this list of conditions and the following disclaimer in the documentation                    *
+*    and/or other materials provided with the distribution.                                       *
+*                                                                                                 *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND                 *
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED                   *
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE                          *
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR                 *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES                  *
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;                    *
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND                     *
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT                      *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS                   *
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                                    *
+*                                                                                                 *
+* Author: Gianluca Frison, gianluca.frison (at) imtek.uni-freiburg.de                             *
+*                                                                                                 *
+**************************************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// headers to reference BLAS and LAPACK routines employed in BLASFEO WR
+
+// level 1
+float sdot_(int *m, float *x, int *incx, float *y, int *incy);
+void scopy_(int *m, float *x, int *incx, float *y, int *incy);
+void saxpy_(int *m, float *alpha, float *x, int *incx, float *y, int *incy);
+void sscal_(int *m, float *alpha, float *x, int *incx);
+void srot_(int *m, float *x, int *incx, float *y, int *incy, float *c, float *s);
+void srotg_(float *a, float *b, float *c, float *s);
+
+// level 2
+void sgemv_(char *ta, int *m, int *n, float *alpha, float *A, int *lda, float *x, int *incx, float *beta, float *y, int *incy);
+void ssymv_(char *uplo, int *m, float *alpha, float *A, int *lda, float *x, int *incx, float *beta, float *y, int *incy);
+void strmv_(char *uplo, char *trans, char *diag, int *n, float *A, int *lda, float *x, int *incx);
+void strsv_(char *uplo, char *trans, char *diag, int *n, float *A, int *lda, float *x, int *incx);
+void sger_(int *m, int *n, float *alpha, float *x, int *incx, float *y, int *incy, float *A, int *lda);
+
+// level 3
+void sgemm_(char *ta, char *tb, int *m, int *n, int *k, float *alpha, float *A, int *lda, float *B, int *ldb, float *beta, float *C, int *ldc);
+void ssyrk_(char *uplo, char *trans, int *n, int *k, float *alpha, float *A, int *lda, float *beta, float *C, int *ldc);
+void strmm_(char *side, char *uplo, char *transa, char *diag, int *m, int *n, float *alpha, float *A, int *lda, float *B, int *ldb);
+void strsm_(char *side, char *uplo, char *transa, char *diag, int *m, int *n, float *alpha, float *A, int *lda, float *B, int *ldb);
+void ssyr2k_(char *uplo, char *trans, int *n, int *k, float *alpha, float *A, int *lda, float *B, int *ldb, float *beta, float *C, int *ldc);
+
+// lapack
+void spotrf_(char *uplo, int *m, float *A, int *lda, int *info);
+void sgetrf_(int *m, int *n, float *A, int *lda, int *ipiv, int *info);
+void sgeqrf_(int *m, int *n, float *A, int *lda, float *tau, float *work, int *lwork, int *info);
+void sgeqr2_(int *m, int *n, float *A, int *lda, float *tau, float *work, int *info);
+void sgelqf_(int *m, int *n, float *A, int *lda, float *tau, float *work, int *lwork, int *info);
+void sorglq_(int *m, int *n, int *k, float *A, int *lda, float *tau, float *work, int *lwork, int *info);
+
+
+
+#ifdef __cplusplus
+}
+#endif

casadi/include/s_blas_64.h

@@ -0,0 +1,73 @@
+/**************************************************************************************************
+*                                                                                                 *
+* This file is part of BLASFEO.                                                                   *
+*                                                                                                 *
+* BLASFEO -- BLAS For Embedded Optimization.                                                      *
+* Copyright (C) 2019 by Gianluca Frison.                                                          *
+* Developed at IMTEK (University of Freiburg) under the supervision of Moritz Diehl.              *
+* All rights reserved.                                                                            *
+*                                                                                                 *
+* The 2-Clause BSD License                                                                        *
+*                                                                                                 *
+* Redistribution and use in source and binary forms, with or without                              *
+* modification, are permitted provided that the following conditions are met:                     *
+*                                                                                                 *
+* 1. Redistributions of source code must retain the above copyright notice, this                  *
+*    list of conditions and the following disclaimer.                                             *
+* 2. Redistributions in binary form must reproduce the above copyright notice,                    *
+*    this list of conditions and the following disclaimer in the documentation                    *
+*    and/or other materials provided with the distribution.                                       *
+*                                                                                                 *
+* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND                 *
+* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED                   *
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE                          *
+* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR                 *
+* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES                  *
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;                    *
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND                     *
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT                      *
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS                   *
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.                                    *
+*                                                                                                 *
+* Author: Gianluca Frison, gianluca.frison (at) imtek.uni-freiburg.de                             *
+*                                                                                                 *
+**************************************************************************************************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+// headers to reference BLAS and LAPACK routines employed in BLASFEO WR
+
+// level 1
+float sdot_(long long *m, float *x, long long *incx, float *y, long long *incy);
+void scopy_(long long *m, float *x, long long *incx, float *y, long long *incy);
+void saxpy_(long long *m, float *alpha, float *x, long long *incx, float *y, long long *incy);
+void sscal_(long long *m, float *alpha, float *x, long long *incx);
+
+// level 2
+void sgemv_(char *ta, long long *m, long long *n, float *alpha, float *A, long long *lda, float *x, long long *incx, float *beta, float *y, long long *incy);
+void ssymv_(char *uplo, long long *m, float *alpha, float *A, long long *lda, float *x, long long *incx, float *beta, float *y, long long *incy);
+void strmv_(char *uplo, char *trans, char *diag, long long *n, float *A, long long *lda, float *x, long long *incx);
+void strsv_(char *uplo, char *trans, char *diag, long long *n, float *A, long long *lda, float *x, long long *incx);
+void sger_(long long *m, long long *n, float *alpha, float *x, long long *incx, float *y, long long *incy, float *A, long long *lda);
+
+// level 3
+void sgemm_(char *ta, char *tb, long long *m, long long *n, long long *k, float *alpha, float *A, long long *lda, float *B, long long *ldb, float *beta, float *C, long long *ldc);
+void ssyrk_(char *uplo, char *trans, long long *n, long long *k, float *alpha, float *A, long long *lda, float *beta, float *C, long long *ldc);
+void strmm_(char *side, char *uplo, char *transa, char *diag, long long *m, long long *n, float *alpha, float *A, long long *lda, float *B, long long *ldb);
+void strsm_(char *side, char *uplo, char *transa, char *diag, long long *m, long long *n, float *alpha, float *A, long long *lda, float *B, long long *ldb);
+
+// lapack
+void spotrf_(char *uplo, long long *m, float *A, long long *lda, long long *info);
+void sgetrf_(long long *m, long long *n, float *A, long long *lda, long long *ipiv, long long *info);
+void sgeqrf_(long long *m, long long *n, float *A, long long *lda, float *tau, float *work, long long *lwork, long long *info);
+void sgeqr2_(long long *m, long long *n, float *A, long long *lda, float *tau, float *work, long long *info);
+
+
+
+#ifdef __cplusplus
+}
+#endif

casadi/include/sleqp/defs.h

@@ -0,0 +1,58 @@
+#ifndef SLEQP_DEFS_H
+#define SLEQP_DEFS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+  typedef enum
+  {
+    SLEQP_SOLVER_GUROBI, SLEQP_SOLVER_HIGHS, SLEQP_SOLVER_SOPLEX
+  } SLEQP_LP_SOLVERS;
+
+#define SLEQP_VERSION "1.0.1"
+
+/* #undef SLEQP_DEBUG */
+#define SLEQP_FORMAT_CODES
+/* #undef SLEQP_ENABLE_NUM_ASSERTS */
+#define SLEQP_HAVE_ATTRIBUTE_WARN_UNUSED_RESULT
+/* #undef SLEQP_HAVE_ATTRIBUTE_NODISCARD */
+#define SLEQP_HAVE_ATTRIBUTE_FORMAT
+/* #undef SLEQP_HAVE_QR_FACT */
+
+#ifdef SLEQP_HAVE_ATTRIBUTE_FORMAT
+#define SLEQP_FORMAT_PRINTF(index, first)                                      \
+  __attribute__((__format__(__printf__, index, first)))
+#else
+#define SLEQP_FORMAT_PRINTF(index, first)
+#endif
+
+#define SLEQP_VERSION_MAJOR 1
+#define SLEQP_VERSION_MINOR 0
+#define SLEQP_VERSION_PATCH 1
+
+#define SLEQP_TRLIB_VERSION "0.4"
+
+#define SLEQP_GIT_BRANCH "patch-1"
+#define SLEQP_GIT_COMMIT_HASH "e9a4553"
+
+#define SLEQP_LONG_VERSION "1.0.1 [patch-1-e9a4553]"
+
+#define SLEQP_LP_SOLVER SLEQP_LP_SOLVER_HIGHS
+#define SLEQP_LP_SOLVER_NAME "HiGHS"
+#define SLEQP_LP_SOLVER_VERSION ""
+
+#define SLEQP_LP_SOLVER_HIGHS_NAME "HiGHS"
+#define SLEQP_LP_SOLVER_HIGHS_VERSION ""
+
+#define SLEQP_FACT_NAME "MUMPS"
+#define SLEQP_FACT_VERSION "5.4.1"
+
+#define SLEQP_FACT_MUMPS_NAME "MUMPS"
+#define SLEQP_FACT_MUMPS_VERSION "5.4.1"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* SLEQP_DEFS_H */

casadi/include/sleqp/export.h

@@ -0,0 +1,43 @@
+
+#ifndef SLEQP_EXPORT_H
+#define SLEQP_EXPORT_H
+
+#ifdef SLEQP_STATIC_DEFINE
+#  define SLEQP_EXPORT
+#  define SLEQP_NO_EXPORT
+#else
+#  ifndef SLEQP_EXPORT
+#    ifdef sleqp_EXPORTS
+        /* We are building this library */
+#      define SLEQP_EXPORT __attribute__((visibility("default")))
+#    else
+        /* We are using this library */
+#      define SLEQP_EXPORT __attribute__((visibility("default")))
+#    endif
+#  endif
+
+#  ifndef SLEQP_NO_EXPORT
+#    define SLEQP_NO_EXPORT __attribute__((visibility("hidden")))
+#  endif
+#endif
+
+#ifndef SLEQP_DEPRECATED
+#  define SLEQP_DEPRECATED __attribute__ ((__deprecated__))
+#endif
+
+#ifndef SLEQP_DEPRECATED_EXPORT
+#  define SLEQP_DEPRECATED_EXPORT SLEQP_EXPORT SLEQP_DEPRECATED
+#endif
+
+#ifndef SLEQP_DEPRECATED_NO_EXPORT
+#  define SLEQP_DEPRECATED_NO_EXPORT SLEQP_NO_EXPORT SLEQP_DEPRECATED
+#endif
+
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
+#if 0 /* DEFINE_NO_DEPRECATED */
+#  ifndef SLEQP_NO_DEPRECATED
+#    define SLEQP_NO_DEPRECATED
+#  endif
+#endif
+
+#endif /* SLEQP_EXPORT_H */

casadi/include/sleqp/pub_cmp.h

@@ -0,0 +1,18 @@
+#ifndef SLEQP_PUB_CMP_H
+#define SLEQP_PUB_CMP_H
+
+/**
+ * @file pub_cmp.h
+ * @brief Definition of numerical comparison functions.
+ **/
+
+#include "sleqp/export.h"
+#include "sleqp/pub_types.h"
+
+SLEQP_EXPORT double
+sleqp_infinity();
+
+SLEQP_EXPORT bool
+sleqp_is_finite(double value);
+
+#endif /* SLEQP_PUB_CMP_H */

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