casadi 3.6.5__cp312-none-manylinux2014_x86_64.whl → 3.6.7__cp312-none-manylinux2014_x86_64.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/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

casadi/include/fatrop/auxiliary/FatropOptions.hpp

@@ -0,0 +1,68 @@
+/*
+ * 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 FATROPOPTIONSINCLUDED
+#define FATROPOPTIONSINCLUDED
+#include <string>
+namespace fatrop
+{
+    class FatropOption
+    {
+    public:
+        FatropOption(const std::string &name, const std::string &descr) :name_(name), description_(descr){
+
+                                            };
+        std::string name_;
+        std::string description_;
+    };
+    class NumericOption : public FatropOption
+    {
+    public:
+        NumericOption(const std::string &name, const std::string &descr, double default_value) : FatropOption(name, descr), value_(default_value), default_value_(default_value) {}
+        virtual void set_value(double value)
+        {
+            value_ = value;
+        }
+        double GetValue()
+        {
+            return value_;
+        }
+
+    private:
+        double value_;
+        double default_value_;
+    };
+    class NumericOptionBounded : public NumericOption
+    {
+        // decorator for NumericOption that also checks bounds
+    public:
+        NumericOptionBounded(const std::string &name, const std::string &descr, double default_value, double lower_bound, double upper_bound) : NumericOption(name, descr, default_value), lower_bound_(lower_bound), upper_bound_(upper_bound){};
+        virtual void set_value(double value)
+        {
+            if ((value > lower_bound_) && (value < upper_bound_))
+            {
+                NumericOption::set_value(value);
+            }
+        }
+
+    private:
+        double lower_bound_;
+        double upper_bound_;
+    };
+} // namespace fatrop
+#endif