casadi 3.6.4__cp27-none-manylinux1_i686.whl → 3.6.6__cp27-none-manylinux1_i686.whl

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/licenses/daqp-external/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Daniel Arnström
+
+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.

casadi/include/osqp/constants.h

@@ -9,8 +9,7 @@ extern "C" {
 /*******************
 * OSQP Versioning *
 *******************/
-# define OSQP_VERSION ("0.6.2") /* string literals automatically null-terminated
-                                   */
+#include "version.h"
 
 /******************
 * Solver Status  *
@@ -33,7 +32,7 @@ extern "C" {
 /*************************
 * Linear System Solvers *
 *************************/
-enum linsys_solver_type { QDLDL_SOLVER, MKL_PARDISO_SOLVER };
+enum linsys_solver_type { QDLDL_SOLVER, MKL_PARDISO_SOLVER, UNKNOWN_SOLVER=99 };
 extern const char * LINSYS_SOLVER_NAME[];
 
 

casadi/include/osqp/version.h

@@ -0,0 +1,9 @@
+/**
+This file is replaced by an auto-generated version.h
+with an OSQP_VERSION obtained from a variable supplied
+to cmake
+*/
+
+#ifndef OSQP_VERSION
+#define OSQP_VERSION "0.6.3"
+#endif

casadi/pkgconfig/casadi.pc

@@ -6,7 +6,7 @@ includedir=/work/install/casadi/include
 Name: casadi
 Description: CasADi is a symbolic framework for automatic differentation and numeric optimization
 URL: http://casadi.org
-Version: 3.6.4
+Version: 3.6.6
 Requires: 
 Libs: -L${libdir} -lcasadi
 Cflags: -I${includedir}

casadi/tools/__init__.py

@@ -25,6 +25,7 @@
 
 from .graph import *
 from .bounds import *
+import os
 
 import sys
 if sys.version_info >= (3,0):
@@ -42,6 +43,9 @@ def loadAllCompiledPlugins():
   for k in CasadiMeta.plugins().split(";"):
     cls, name = k.split("::")
     print("Testing: ", cls, name)
+    if "SKIP_" + name.upper() + "_TESTS" in os.environ:
+        print("Skipping")
+        continue
     if cls in ("Importer","XmlFile","Linsol"):
       getattr(casadi,cls).load_plugin(name)
     else:

casadi/tools/bounds.py

@@ -22,7 +22,7 @@
 #
 #
 from casadi import *
-from numpy import Inf
+from numpy import inf
 
 def reportBounds(value,lowerbound,upperbound,labels=None,tol=1e-8,showNonViolating=True):
   if hasattr(labels,"labels"):
@@ -75,13 +75,13 @@ def reportBounds(value,lowerbound,upperbound,labels=None,tol=1e-8,showNonViolati
       indicator = ""
     else:
       indicator = "-" * indicator_length
-      if lb[i]==Inf:
+      if lb[i]==inf:
         indicator = "8" +  indicator
       elif (abs(v[i]-lb[i])<=tol):
         indicator = "X" +  indicator
       else:
         indicator = "o" +  indicator
-      if ub[i]==Inf:
+      if ub[i]==inf:
         indicator += "8"
       elif (abs(v[i]-ub[i])<=tol):
         indicator += "X"

{casadi-3.6.4.dist-info → casadi-3.6.6.dist-info}/METADATA

@@ -1,12 +1,15 @@
-Metadata-Version: 2.0
+Metadata-Version: 2.1
 Name: casadi
-Version: 3.6.4
+Version: 3.6.6
 Summary: CasADi -- framework for algorithmic differentiation and numeric optimization
 Home-page: http://casadi.org
 Author: Joel Andersson, Joris Gillis, Greg Horn
 Author-email:  developer_first_name@casadi.org
 License: GNU Lesser General Public License v3 or later (LGPLv3+)
-Download-URL: http://casadi.org
+Download-URL: http://install.casadi.org
+Project-URL: Documentation, http://docs.casadi.org
+Project-URL: Bug Tracker, https://github.com/casadi/casadi/issues
+Project-URL: Source Code, https://github.com/casadi/casadi
 Platform: Windows
 Platform: Linux
 Platform: Mac OS-X
@@ -26,6 +29,8 @@ Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Scientific/Engineering
 Classifier: Operating System :: Microsoft :: Windows
@@ -34,4 +39,7 @@ Classifier: Operating System :: Unix
 Classifier: Operating System :: MacOS
 Requires-Dist: numpy
 
-CasADi is a symbolic framework for numeric optimization implementing automatic differentiation in forward and reverse modes on sparse matrix-valued computational graphs. It supports self-contained C-code generation and interfaces state-of-the-art codes such as SUNDIALS, IPOPT etc. It can be used from C++, Python or Matlab/Octave.
+CasADi is a symbolic framework for numeric optimization implementing automatic differentiation in forward and reverse modes on sparse matrix-valued computational graphs. It supports self-contained C-code generation and interfaces state-of-the-art codes such as SUNDIALS, IPOPT etc. It can be used from C++, Python or Matlab/Octave.
+
+Example pack can be downloaded from http://install.casadi.org
+