casadi 3.6.4__cp311-none-manylinux2014_i686.whl → 3.6.6__cp311-none-manylinux2014_i686.whl

casadi/include/coin-or/mumps/dmumps_c.h

@@ -0,0 +1,142 @@
+/*
+ *
+ *  This file is part of MUMPS 5.4.1, released
+ *  on Tue Aug  3 09:49:43 UTC 2021
+ *
+ *
+ *  Copyright 1991-2021 CERFACS, CNRS, ENS Lyon, INP Toulouse, Inria,
+ *  Mumps Technologies, University of Bordeaux.
+ *
+ *  This version of MUMPS is provided to you free of charge. It is
+ *  released under the CeCILL-C license 
+ *  (see doc/CeCILL-C_V1-en.txt, doc/CeCILL-C_V1-fr.txt, and
+ *  https://cecill.info/licences/Licence_CeCILL-C_V1-en.html)
+ *
+ */
+
+/* Mostly written in march 2002 (JYL) */
+
+#ifndef DMUMPS_C_H
+#define DMUMPS_C_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "mumps_compat.h"
+/* Next line defines MUMPS_INT, DMUMPS_COMPLEX and DMUMPS_REAL */
+#include "mumps_c_types.h"
+
+#ifndef MUMPS_VERSION
+/* Protected in case headers of other arithmetics are included */
+#define MUMPS_VERSION "5.4.1"
+#endif
+#ifndef MUMPS_VERSION_MAX_LEN
+#define MUMPS_VERSION_MAX_LEN 30
+#endif
+
+/*
+ * Definition of the (simplified) MUMPS C structure.
+ * NB: DMUMPS_COMPLEX are REAL types in s and d arithmetics.
+ */
+typedef struct {
+
+    MUMPS_INT      sym, par, job;
+    MUMPS_INT      comm_fortran;    /* Fortran communicator */
+    MUMPS_INT      icntl[60];
+    MUMPS_INT      keep[500];
+    DMUMPS_REAL    cntl[15];
+    DMUMPS_REAL    dkeep[230];
+    MUMPS_INT8     keep8[150];
+    MUMPS_INT      n;
+    MUMPS_INT      nblk;
+
+    MUMPS_INT      nz_alloc; /* used in matlab interface to decide if we
+                                free + malloc when we have large variation */
+
+    /* Assembled entry */
+    MUMPS_INT      nz;
+    MUMPS_INT8     nnz;
+    MUMPS_INT      *irn;
+    MUMPS_INT      *jcn;
+    DMUMPS_COMPLEX *a;
+
+    /* Distributed entry */
+    MUMPS_INT      nz_loc;
+    MUMPS_INT8     nnz_loc;
+    MUMPS_INT      *irn_loc;
+    MUMPS_INT      *jcn_loc;
+    DMUMPS_COMPLEX *a_loc;
+
+    /* Element entry */
+    MUMPS_INT      nelt;
+    MUMPS_INT      *eltptr;
+    MUMPS_INT      *eltvar;
+    DMUMPS_COMPLEX *a_elt;
+
+    /* Matrix by blocks */
+    MUMPS_INT      *blkptr;
+    MUMPS_INT      *blkvar;
+
+    /* Ordering, if given by user */
+    MUMPS_INT      *perm_in;
+
+    /* Orderings returned to user */
+    MUMPS_INT      *sym_perm;    /* symmetric permutation */
+    MUMPS_INT      *uns_perm;    /* column permutation */
+
+    /* Scaling (inout but complicated) */
+    DMUMPS_REAL    *colsca;
+    DMUMPS_REAL    *rowsca;
+    MUMPS_INT colsca_from_mumps;
+    MUMPS_INT rowsca_from_mumps;
+
+    /* RHS, solution, ouptput data and statistics */
+    DMUMPS_COMPLEX *rhs, *redrhs, *rhs_sparse, *sol_loc, *rhs_loc;
+    MUMPS_INT      *irhs_sparse, *irhs_ptr, *isol_loc, *irhs_loc;
+    MUMPS_INT      nrhs, lrhs, lredrhs, nz_rhs, lsol_loc, nloc_rhs, lrhs_loc;
+    MUMPS_INT      schur_mloc, schur_nloc, schur_lld;
+    MUMPS_INT      mblock, nblock, nprow, npcol;
+    MUMPS_INT      info[80],infog[80];
+    DMUMPS_REAL    rinfo[40], rinfog[40];
+
+    /* Null space */
+    MUMPS_INT      deficiency;
+    MUMPS_INT      *pivnul_list;
+    MUMPS_INT      *mapping;
+
+    /* Schur */
+    MUMPS_INT      size_schur;
+    MUMPS_INT      *listvar_schur;
+    DMUMPS_COMPLEX *schur;
+
+    /* Internal parameters */
+    MUMPS_INT      instance_number;
+    DMUMPS_COMPLEX *wk_user;
+
+    /* Version number: length=14 in FORTRAN + 1 for final \0 + 1 for alignment */
+    char version_number[MUMPS_VERSION_MAX_LEN + 1 + 1];
+    /* For out-of-core */
+    char ooc_tmpdir[256];
+    char ooc_prefix[64];
+    /* To save the matrix in matrix market format */
+    char write_problem[256];
+    MUMPS_INT      lwk_user;
+    /* For save/restore feature */
+    char save_dir[256];
+    char save_prefix[256];
+
+    /* Metis options */
+    MUMPS_INT metis_options[40];
+} DMUMPS_STRUC_C;
+
+
+void MUMPS_CALL
+dmumps_c( DMUMPS_STRUC_C * dmumps_par );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* DMUMPS_C_H */
+

casadi/include/coin-or/mumps/mumps_c_types.h

@@ -0,0 +1,72 @@
+/*
+ *
+ *  This file is part of MUMPS 5.4.1, released
+ *  on Tue Aug  3 09:49:43 UTC 2021
+ *
+ *
+ *  Copyright 1991-2021 CERFACS, CNRS, ENS Lyon, INP Toulouse, Inria,
+ *  Mumps Technologies, University of Bordeaux.
+ *
+ *  This version of MUMPS is provided to you free of charge. It is
+ *  released under the CeCILL-C license 
+ *  (see doc/CeCILL-C_V1-en.txt, doc/CeCILL-C_V1-fr.txt, and
+ *  https://cecill.info/licences/Licence_CeCILL-C_V1-en.html)
+ *
+ */
+
+
+#ifndef MUMPS_C_TYPES_H
+#define MUMPS_C_TYPES_H
+
+#include <stdint.h>
+
+/* mumps_int_def.h will define either MUMPS_INTSIZE32 (default)
+   or MUMPS_INTSIZE64 (if compilation is with -DINTSIZE64 to
+   match Fortran -i8 or equivalent option). This allows one to
+   test from an external code whether MUMPS_INT is 64bits or not */
+#include "mumps_int_def.h"
+
+#ifdef MUMPS_INTSIZE64
+#define MUMPS_INT int64_t
+#else
+#define MUMPS_INT int
+#endif
+
+#define MUMPS_INT8 int64_t
+
+#define SMUMPS_COMPLEX float
+#define SMUMPS_REAL float
+
+#define DMUMPS_COMPLEX double
+#define DMUMPS_REAL double
+
+/* Complex datatypes */
+typedef struct {float r,i;} mumps_complex;
+typedef struct {double r,i;} mumps_double_complex;
+
+#define CMUMPS_COMPLEX mumps_complex
+#define CMUMPS_REAL float
+
+#define ZMUMPS_COMPLEX mumps_double_complex
+#define ZMUMPS_REAL double
+
+
+#ifndef mumps_ftnlen
+/* When passing a string, what is the type of the extra argument
+ * passed by value ? */
+# define mumps_ftnlen MUMPS_INT
+#endif
+
+
+#define MUMPS_ARITH_s 1
+#define MUMPS_ARITH_d 2
+#define MUMPS_ARITH_c 4
+#define MUMPS_ARITH_z 8
+
+#define MUMPS_ARITH_REAL   ( MUMPS_ARITH_s | MUMPS_ARITH_d )
+#define MUMPS_ARITH_CMPLX  ( MUMPS_ARITH_c | MUMPS_ARITH_z )
+#define MUMPS_ARITH_SINGLE ( MUMPS_ARITH_s | MUMPS_ARITH_c )
+#define MUMPS_ARITH_DBL    ( MUMPS_ARITH_d | MUMPS_ARITH_z )
+
+
+#endif /* MUMPS_C_TYPES_H */

casadi/include/coin-or/mumps/mumps_compat.h

@@ -0,0 +1,27 @@
+/* mumps_compat.h.  Generated from mumps_compat.h.in by configure.  */
+/* mumps_compat.h.in. */
+
+#ifndef MUMPS_COMPAT_H
+#define MUMPS_COMPAT_H
+
+#ifndef MUMPS_CALL
+/* Define Mumps calling convention. */
+#define MUMPS_CALL 
+#endif
+
+/* tell using codes that we changed mpi.h to mumps_mpi.h */
+#define COIN_USE_MUMPS_MPI_H
+
+/* copied from MUMPS' own mumps_compat.h */
+#if defined(_WIN32) && ! defined(__MINGW32__)
+# define MUMPS_WIN32 1
+#endif
+
+#if (__STDC_VERSION__ >= 199901L)
+# define MUMPS_INLINE static inline
+#else
+# define MUMPS_INLINE
+#endif
+
+
+#endif /* MUMPS_COMPAT_H */

casadi/include/coin-or/mumps/mumps_int_def.h

@@ -0,0 +1,11 @@
+/* mumps_int_def.h.  Generated from mumps_int_def.h.in by configure.  */
+#ifndef MUMPS_INT_H
+#define MUMPS_INT_H
+
+/* Define if MUMPS integers have a size of 32-bit */
+#define MUMPS_INTSIZE32 /**/
+
+/* Define if MUMPS integers have a size of 64-bit */
+/* #undef MUMPS_INTSIZE64 */
+
+#endif

casadi/include/coin-or/mumps/mumps_mpi.h

@@ -0,0 +1,67 @@
+/*
+ *
+ *  This file is part of MUMPS 5.4.1, released
+ *  on Tue Aug  3 09:49:43 UTC 2021
+ *
+ *
+ *  Copyright 1991-2021 CERFACS, CNRS, ENS Lyon, INP Toulouse, Inria,
+ *  Mumps Technologies, University of Bordeaux.
+ *
+ *  This version of MUMPS is provided to you free of charge. It is
+ *  released under the CeCILL-C license 
+ *  (see doc/CeCILL-C_V1-en.txt, doc/CeCILL-C_V1-fr.txt, and
+ *  https://cecill.info/licences/Licence_CeCILL-C_V1-en.html)
+ *
+ */
+#ifdef INTSIZE64
+#include <inttypes.h>
+#define LIBSEQ_INT int64_t
+#else
+#define LIBSEQ_INT int
+#endif
+
+#if ! defined(LIBSEQ_CALL)
+#if defined(_WIN32) && ! defined(__MINGW32__)
+/* Choose between next lines or modify according
+ * to your Windows calling conventions:
+   #define LIBSEQ_CALL
+   #define LIBSEQ_CALL __declspec(dllexport)
+   #define LIBSEQ_CALL __declspec(dllexport) */
+#define LIBSEQ_CALL
+#else
+#define LIBSEQ_CALL
+#endif
+#endif
+
+
+#ifndef MUMPS_MPI_H
+#define MUMPS_MPI_H
+
+/* We define all symbols as extern "C" for users who call MUMPS with its
+   libseq from a C++ driver. */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* This is the minimum to have the C interface to MUMPS work with the
+ * C example provided. Other stub functions of the MPI standard may be
+ * added if needed. */
+
+typedef LIBSEQ_INT MPI_Comm; /* Simple type for MPI communicator */
+static MPI_Comm MPI_COMM_WORLD=(MPI_Comm)0;
+
+LIBSEQ_INT LIBSEQ_CALL MPI_Init(LIBSEQ_INT *pargc, char ***pargv);
+LIBSEQ_INT LIBSEQ_CALL MPI_Comm_rank(LIBSEQ_INT  comm, LIBSEQ_INT  *rank);
+LIBSEQ_INT LIBSEQ_CALL MPI_Finalize(void);
+
+/* For MPI_IS_IN_PLACE tests */
+void LIBSEQ_CALL MUMPS_CHECKADDREQUAL(char *a, char*b, LIBSEQ_INT *i);
+void LIBSEQ_CALL MUMPS_CHECKADDREQUAL_(char *a, char*b, LIBSEQ_INT *i);
+void LIBSEQ_CALL mumps_checkaddrequal_(char *a, char*b, LIBSEQ_INT *i);
+void LIBSEQ_CALL mumps_checkaddrequal__(char *a, char*b, LIBSEQ_INT *i);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MUMPS_MPI_H */

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