casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.7__cp312-none-win_amd64.whl

casadi/include/casadi/mem.h

@@ -46,6 +46,7 @@ extern "C" {
 #endif
 
 /* Function types corresponding to entry points in CasADi's C API */
+typedef int (*casadi_config_t)(int, const char**);
 typedef void (*casadi_signal_t)(void);
 typedef casadi_int (*casadi_getint_t)(void);
 typedef int (*casadi_checkout_t)(void);

casadi/include/daqp/api.h

@@ -0,0 +1,46 @@
+#ifndef DAQP_API_H
+# define DAQP_API_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include "daqp.h"
+#include "daqp_prox.h"
+#include "bnb.h"
+
+typedef struct{
+    c_float *x;
+    c_float *lam;
+    c_float fval;
+    c_float soft_slack;
+
+    int exitflag;
+    int iter;
+    int nodes;
+    c_float solve_time;
+    c_float setup_time;
+
+}DAQPResult;
+
+void daqp_solve(DAQPResult* res, DAQPWorkspace *work);
+void daqp_quadprog(DAQPResult* res, DAQPProblem* qp,DAQPSettings* settings);
+
+int setup_daqp(DAQPProblem *qp, DAQPWorkspace* work, c_float* setup_time);
+int setup_daqp_ldp(DAQPWorkspace *work, DAQPProblem* qp);
+int setup_daqp_bnb(DAQPWorkspace* work, int nb, int ns);
+void allocate_daqp_settings(DAQPWorkspace *work);
+void allocate_daqp_workspace(DAQPWorkspace *work, int n, int ns);
+
+void free_daqp_ldp(DAQPWorkspace *work);
+void free_daqp_workspace(DAQPWorkspace *work);
+void free_daqp_bnb(DAQPWorkspace* work);
+
+void daqp_extract_result(DAQPResult* res, DAQPWorkspace* work);
+void daqp_default_settings(DAQPSettings *settings);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_API_H

casadi/include/daqp/auxiliary.h

@@ -0,0 +1,29 @@
+#ifndef DAQP_AUX_H 
+# define DAQP_AUX_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include "types.h"
+#include "constants.h"
+
+void remove_constraint(DAQPWorkspace* work, const int rm_ind);
+void add_constraint(DAQPWorkspace *work, const int add_ind, c_float lam);
+void compute_primal_and_fval(DAQPWorkspace *work);
+int add_infeasible(DAQPWorkspace *work);
+int remove_blocking(DAQPWorkspace *work);
+void compute_CSP(DAQPWorkspace *work);
+void compute_singular_direction(DAQPWorkspace *work);
+
+void reorder_LDL(DAQPWorkspace *work);
+void pivot_last(DAQPWorkspace *work);
+
+int activate_constraints(DAQPWorkspace *work);
+void deactivate_constraints(DAQPWorkspace *work);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_AUX_H

casadi/include/daqp/bnb.h

@@ -0,0 +1,32 @@
+#ifndef DAQP_BNB_H 
+# define DAQP_BNB_H 
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include "types.h"
+#include "constants.h"
+#include "daqp.h"
+
+int daqp_bnb(DAQPWorkspace* work);
+int process_node(DAQPNode* node, DAQPWorkspace* work);
+int get_branch_id(DAQPWorkspace* work);
+void spawn_children(DAQPNode* node, const int branch_id, DAQPWorkspace* work);
+
+void node_cleanup_workspace(int n_clean, DAQPWorkspace* work);
+void warmstart_node(DAQPNode* node, DAQPWorkspace* work); 
+void save_warmstart(DAQPNode* node, DAQPWorkspace* work);
+int add_upper_lower(const int add_id, DAQPWorkspace* work); 
+
+#define LOWER_BIT 16
+#define EXTRACT_LOWER_FLAG(x) (x>>(LOWER_BIT-1))
+#define REMOVE_LOWER_FLAG(x) (x&~(1<<LOWER_BIT))
+#define ADD_LOWER_FLAG(x) (x|(1<<LOWER_BIT))
+#define TOGGLE_LOWER_FLAG(x) (x^(1<<LOWER_BIT))
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_BNB_H 

casadi/include/daqp/codegen.h

@@ -0,0 +1,18 @@
+#ifndef DAQP_CODEGEN_H
+#define DAQP_CODEGEN_H
+
+#include <stdio.h>
+#include "types.h"
+
+void render_daqp_workspace(DAQPWorkspace* work, const char *fname, const char* dir);
+
+void write_daqp_workspace_h(FILE *f, DAQPWorkspace *work);
+void write_daqp_workspace_src(FILE *f, DAQPWorkspace *work);
+void write_daqp_settings_src(FILE*  f, DAQPSettings* settings);
+void write_daqp_bnb_h(FILE*  f, DAQPBnB* bnb, const int n);
+void write_daqp_bnb_src(FILE*  f, DAQPBnB* bnb, const int n);
+
+void write_float_array(FILE *f, c_float* a, const int N, const char *name);
+void write_int_array(FILE *f, int* a, const int N, const char *name);
+
+#endif //ifndef DAQP_CODEGEN_H

casadi/include/daqp/constants.h

@@ -0,0 +1,92 @@
+#ifndef DAQP_CONSTANTS_H
+#define DAQP_CONSTANTS_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include <stddef.h>
+
+#define EMPTY_IND -1 
+#define NX work->n 
+#define N_CONSTR work->m 
+#define N_SIMPLE work->ms 
+#define DAQP_INF ((c_float)1e30)
+
+// DEFAULT SETTINGS 
+#define DEFAULT_PRIM_TOL 1e-6
+#define DEFAULT_DUAL_TOL 1e-12 
+#define DEFAULT_ZERO_TOL 1e-11
+#define DEFAULT_PROG_TOL 1e-14 
+#define DEFAULT_PIVOT_TOL 1e-6
+#define DEFAULT_CYCLE_TOL 10
+#define DEFAULT_ETA 1e-6
+#define DEFAULT_ITER_LIMIT 1000 
+#define DEFAULT_RHO_SOFT 1e-3
+#define DEFAULT_REL_SUBOPT 0
+#define DEFAULT_ABS_SUBOPT 0
+
+// MACROS
+#define SQUARE(x) ((x)*(x))
+#define ARSUM(x) ((x)*(x+1)/2)
+#define R_OFFSET(X,Y) (((2*Y-X-1)*X)/2)
+
+// EXIT FLAGS
+#define EXIT_SOFT_OPTIMAL 2 
+#define EXIT_OPTIMAL 1
+#define EXIT_INFEASIBLE -1
+#define EXIT_CYCLE -2
+#define EXIT_UNBOUNDED -3
+#define EXIT_ITERLIMIT -4
+#define EXIT_NONCONVEX -5
+#define EXIT_OVERDETERMINED_INITIAL -6
+
+// UPDATE LDP MASKS 
+#define UPDATE_Rinv 1
+#define UPDATE_M 2
+#define UPDATE_v 4
+#define UPDATE_d 8
+#define UPDATE_sense 16 
+
+// CONSTRAINT MASKS 
+#define ACTIVE 1
+#define IS_ACTIVE(x) (work->sense[x]&1)
+#define SET_ACTIVE(x) (work->sense[x]|=1)
+#define SET_INACTIVE(x) (work->sense[x]&=~1)
+
+// marks if a constraints is active at its lower bound
+#define LOWER 2 
+#define IS_LOWER(x) (work->sense[x]&2)
+#define SET_LOWER(x) (work->sense[x]|=2)
+#define SET_UPPER(x) (work->sense[x]&=~2)
+
+// marks if a constraint cannot be activated/deactivated
+#define IMMUTABLE 4 
+#define IS_IMMUTABLE(x) (work->sense[x]&4)
+#define SET_IMMUTABLE(x) (work->sense[x]|=4)
+#define SET_MUTABLE(x) (work->sense[x]&=~4)
+
+// marks that a constraint might be violated (but the slack is penalized)
+#define SOFT 8
+#define IS_SOFT(x) (work->sense[x]&8)
+#define SET_SOFT(x) (work->sense[x]|=8)
+#define SET_HARD(x) (work->sense[x]&=~8)
+
+// marks that a constraint has to be active at either its upper or lower bound 
+#define BINARY 16 
+#define IS_BINARY(x) (work->sense[x]&16)
+
+// marks that the soft slack is at its lower bound (d_ls or d_us) 
+#define SLACK_FIXED 32
+#define IS_SLACK_FIXED(x) (work->sense[x]&32)
+#define IS_SLACK_FREE(x) ((work->sense[x]&32)==0)
+#define SET_SLACK_FIXED(x) (work->sense[x]|=32)
+#define SET_SLACK_FREE(x) (work->sense[x]&=~32)
+
+#define IS_SIMPLE(x) (x < work->ms)
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_CONSTANTS_H

casadi/include/daqp/daqp.h

@@ -0,0 +1,22 @@
+#ifndef DAQP_H
+# define DAQP_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include "factorization.h" 
+#include "constants.h"
+#include "auxiliary.h"
+
+int daqp_ldp(DAQPWorkspace *work);
+void ldp2qp_solution(DAQPWorkspace *work);
+
+void warmstart_workspace(DAQPWorkspace* work, int* WS, const int n_active); 
+void reset_daqp_workspace(DAQPWorkspace *work);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_H

casadi/include/daqp/daqp_prox.h

@@ -0,0 +1,18 @@
+#ifndef DAQP_PROX_H 
+# define DAQP_PROX_H 
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include "types.h"
+#include "constants.h"
+#include "daqp.h"
+
+int daqp_prox(DAQPWorkspace *work);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_PROX_H 

casadi/include/daqp/factorization.h

@@ -0,0 +1,18 @@
+#ifndef DAQP_FACTORIZATION_H
+# define DAQP_FACTORIZATION_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include "types.h"
+#include "constants.h"
+
+void update_LDL_add(DAQPWorkspace *work, const int add_ind);
+void update_LDL_remove(DAQPWorkspace *work, const int rm_ind);
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_FACTORIZATION_H

casadi/include/daqp/types.h

@@ -0,0 +1,161 @@
+#ifndef DAQP_TYPES_H
+# define DAQP_TYPES_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#ifdef DAQP_SINGLE_PRECISION
+typedef float c_float;
+#else
+typedef double c_float;
+#endif
+
+typedef struct{
+
+    // Data for the QP problem
+    //
+    // min  0.5 x'*H*x + f'x
+    // s.t  lbA <= A*x <= ubA
+    //      lb  <=  x  <= ub
+    //
+    // n  - dimension of x
+    // m  - total number of constraints
+    // ms - number of simple bounds
+    // blower = [lb; lbA];
+    // bupper = [ub; ubA];
+    // (The number of rows in A is hence m-ms)
+
+    // sense define the state of the constraints 
+    // (active, immutable, upper/lower, soft, binary).
+
+    int n;
+    int m;
+    int ms;
+
+    c_float* H;
+    c_float* f;
+
+    c_float* A;
+    c_float* bupper;
+    c_float* blower;
+
+    int* sense; 
+
+}DAQPProblem;
+
+typedef struct{
+    c_float primal_tol;
+    c_float dual_tol;
+    c_float zero_tol;
+    c_float pivot_tol;
+    c_float progress_tol;
+
+    int cycle_tol;
+    int iter_limit;
+    c_float fval_bound;
+
+    c_float eps_prox;
+    c_float eta_prox;
+
+    c_float rho_soft;
+
+    c_float rel_subopt;
+    c_float abs_subopt;
+}DAQPSettings;
+
+
+typedef struct{
+    int bin_id;
+    int depth;
+    int WS_start;
+    int WS_end;
+}DAQPNode;
+
+typedef struct{
+    int* bin_ids;
+    int nb;
+    int neq;
+
+    DAQPNode* tree;
+    int  n_nodes;
+
+    int* tree_WS;
+    int nWS;
+    int n_clean;
+    int* fixed_ids;
+
+    int nodecount;
+    int itercount;
+}DAQPBnB;
+
+typedef struct{
+    DAQPProblem* qp;
+    // LDP data 
+    int n; // Number of primal variables
+    int m; // Number of constraints  
+    int ms; // Number of simple bounds
+    c_float *M; // M' M is the Hessian of the dual objective function (dimensions: n x m)  
+    c_float *dupper; // Linear part of dual objective function (dimensions: m x 1) 
+    c_float *dlower; // Linear part of dual objective function (dimensions: m x 1) 
+    c_float *Rinv; // Inverse of upper cholesky factor of primal Hessian 
+    c_float *v; // v = R'\f (used to transform QP to LDP 
+    int *sense; // State of constraints  
+    c_float *scaling; // normalizations 
+    c_float *RinvD; // in case Rinv is diagonal
+
+
+    // Iterates
+    c_float *x; // The final primal solution
+    c_float *xold; // The latest primal solution (used for proximal-point iteratios)
+
+    c_float* lam; // Dual iterate 
+    c_float* lam_star; // Current constrained stationary point 
+    c_float* u; // Stores Mk' lam_star
+    c_float fval;
+
+    // LDL factors (Mk Mk' = L D L')
+    c_float *L;
+    c_float *D;
+    // Intermittent variables (LDL')
+    c_float* xldl; // Solution to L xdldl = -dk
+    c_float* zldl; // zldl_i = xldl_i/D_i
+    int reuse_ind; // How much work that can be saved when solving Mk Mk' lam* = -dk
+
+    int *WS; // Working set, size: maximum number of constraints (n+ns+1)
+    int n_active; // Number of active contraints 
+
+    int iterations;
+    int sing_ind; // Flag for denoting whether Mk Mk' is singular or not 
+
+
+    // Soft constraint
+    c_float soft_slack;
+#ifdef SOFT_WEIGHTS
+    // The softened objective is given by
+    //    min  0.5 x'*H*x + f'x + 0.5 su'su+0.5*sl'sl,
+    // and the softened constraints are given by (similar for simple bounds)
+    //    lbA-rho_ls*sl <= A*x <= ubA+rho_us*su,
+    // with the bounds sl >= d_ls, su >= d_us
+    // note that lbA/ubA is assumed to be shifted with rho_ls*d_ls and rho_us*d_us
+    // since the slacks are assumed to be active at their bounds by default.
+
+    // size of the following is m; values are only used if index set to SOFT.
+    c_float *d_ls;
+    c_float *d_us;
+    c_float *rho_ls;
+    c_float *rho_us;
+#endif
+
+    // Settings
+    DAQPSettings* settings;
+
+    // BnB
+    DAQPBnB* bnb;
+}DAQPWorkspace;
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_TYPES_H

casadi/include/daqp/utils.h

@@ -0,0 +1,44 @@
+#ifndef DAQP_UTILS_H
+# define DAQP_UTILS_H
+
+# ifdef __cplusplus
+extern "C" {
+# endif // ifdef __cplusplus
+
+#include "daqp.h"
+// Utils for transforming QP to LDP
+int update_ldp(const int mask, DAQPWorkspace *work);
+int update_Rinv(DAQPWorkspace *work);
+void update_M(DAQPWorkspace *work, const int mask);
+void update_v(c_float *f, DAQPWorkspace *work, const int mask);
+void update_d(DAQPWorkspace *work);
+void normalize_Rinv(DAQPWorkspace *work);
+void normalize_M(DAQPWorkspace *work);
+//
+// Utils for profiling
+#ifdef PROFILING
+#ifdef _WIN32
+#include <windows.h>
+typedef struct{ 
+    LARGE_INTEGER start;
+    LARGE_INTEGER stop;
+}DAQPtimer;
+#else // not _WIN32 
+#include <time.h>
+typedef struct{ 
+    struct timespec start;
+    struct timespec stop;
+}DAQPtimer;
+#endif // _WIN32
+
+
+void tic(DAQPtimer *timer);
+void toc(DAQPtimer *timer);
+double get_time(DAQPtimer *timer);
+#endif // PROFILING
+
+# ifdef __cplusplus
+}
+# endif // ifdef __cplusplus
+
+#endif //ifndef DAQP_UTILS_H

casadi/include/dlfcn.h

@@ -0,0 +1,94 @@
+/*
+ * dlfcn-win32
+ * Copyright (c) 2007 Ramiro Polla
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef DLFCN_H
+#define DLFCN_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(DLFCN_WIN32_SHARED)
+#if defined(DLFCN_WIN32_EXPORTS)
+#   define DLFCN_EXPORT __declspec(dllexport)
+#else
+#   define DLFCN_EXPORT __declspec(dllimport)
+#endif
+#else
+#   define DLFCN_EXPORT
+#endif
+
+/* Relocations are performed when the object is loaded. */
+#define RTLD_NOW    0
+
+/* Relocations are performed at an implementation-defined time.
+ * Windows API does not support lazy symbol resolving (when first reference
+ * to a given symbol occurs). So RTLD_LAZY implementation is same as RTLD_NOW.
+ */
+#define RTLD_LAZY   RTLD_NOW
+
+/* All symbols are available for relocation processing of other modules. */
+#define RTLD_GLOBAL (1 << 1)
+
+/* All symbols are not made available for relocation processing by other modules. */
+#define RTLD_LOCAL  (1 << 2)
+
+/* These two were added in The Open Group Base Specifications Issue 6.
+ * Note: All other RTLD_* flags in any dlfcn.h are not standard compliant.
+ */
+
+/* The symbol lookup happens in the normal global scope. */
+#define RTLD_DEFAULT    ((void *)0)
+
+/* Specifies the next object after this one that defines name. */
+#define RTLD_NEXT       ((void *)-1)
+
+/* Structure filled in by dladdr() */
+typedef struct dl_info
+{
+   const char *dli_fname;  /* Filename of defining object (thread unsafe and reused on every call to dladdr) */
+   void       *dli_fbase;  /* Load address of that object */
+   const char *dli_sname;  /* Name of nearest lower symbol */
+   void       *dli_saddr;  /* Exact value of nearest symbol */
+} Dl_info;
+
+/* Open a symbol table handle. */
+DLFCN_EXPORT void *dlopen(const char *file, int mode);
+
+/* Close a symbol table handle. */
+DLFCN_EXPORT int dlclose(void *handle);
+
+/* Get the address of a symbol from a symbol table handle. */
+DLFCN_EXPORT void *dlsym(void *handle, const char *name);
+
+/* Get diagnostic information. */
+DLFCN_EXPORT char *dlerror(void);
+
+/* Translate address to symbolic information (no POSIX standard) */
+DLFCN_EXPORT int dladdr(const void *addr, Dl_info *info);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DLFCN_H */

casadi/include/fatrop/auxiliary/Common.hpp

@@ -0,0 +1,34 @@
+/*
+ * Fatrop - A fast trajectory optimization solver
+ *  Copyright (C) 2022 - 2024 Lander Vanroye, KU Leuven. All rights reserved.
+ *
+ * This file is part of Fatrop.
+ *
+ * Fatrop is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fatrop is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Fatrop.  If not, see <http://www.gnu.org/licenses/>. */
+#ifndef COMMONINCLUDED
+#define COMMONINCLUDED
+#include <cassert>
+#if DEBUG
+#define DBGASSERT(assertion) assert(assertion);
+#else
+#define DBGASSERT(assertion)
+#endif
+
+#define fatrop_int int
+namespace fatrop
+{
+    bool CompareLessEqual(double lhs, double rhs);
+    bool CompareLessEqual(double lhs, double rhs, double ref);
+} // namespace fatrop
+#endif //  COMMONINCLUDED

casadi/include/fatrop/auxiliary/DynamicLib.hpp

@@ -0,0 +1,34 @@
+/*
+ * Fatrop - A fast trajectory optimization solver
+ *  Copyright (C) 2022 - 2024 Lander Vanroye, KU Leuven. All rights reserved.
+ *
+ * This file is part of Fatrop.
+ *
+ * Fatrop is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Fatrop is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Fatrop.  If not, see <http://www.gnu.org/licenses/>. */
+#ifndef DYNAMICLIBINCLUDED
+#define DYNAMICLIBINCLUDED
+#include <dlfcn.h>
+#include <string>
+namespace fatrop
+{
+    class DLHandler 
+    {
+    public:
+        DLHandler(const std::string &filename);
+        ~DLHandler();
+        void *handle;
+    };
+
+};     // namespace fatrop
+#endif // DYNAMICLIBINCLUDED