casadi 3.6.5__cp310-none-win_amd64.whl → 3.6.7__cp310-none-win_amd64.whl

casadi/include/highs/mip/HighsPseudocost.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -154,7 +154,7 @@ class HighsPseudocost {
 
       d = unit_gain - cost_total;
       ++nsamplestotal;
-      cost_total += d / nsamplestotal;
+      cost_total += d / static_cast<double>(nsamplestotal);
     } else {
       double unit_gain = -objdelta / delta;
       double d = unit_gain - pseudocostdown[col];
@@ -163,7 +163,7 @@ class HighsPseudocost {
 
       d = unit_gain - cost_total;
       ++nsamplestotal;
-      cost_total += d / nsamplestotal;
+      cost_total += d / static_cast<double>(nsamplestotal);
     }
   }
 
@@ -171,7 +171,7 @@ class HighsPseudocost {
                                bool upbranch) {
     double d = ninferences - inferences_total;
     ++ninferencestotal;
-    inferences_total += d / ninferencestotal;
+    inferences_total += d / static_cast<double>(ninferencestotal);
     if (upbranch) {
       d = ninferences - inferencesup[col];
       ninferencesup[col] += 1;
@@ -202,9 +202,10 @@ class HighsPseudocost {
     double cost;
 
     if (nsamplesup[col] == 0 || nsamplesup[col] < minreliable) {
-      double weightPs = nsamplesup[col] == 0
-                            ? 0
-                            : 0.9 + 0.1 * nsamplesup[col] / (double)minreliable;
+      double weightPs =
+          nsamplesup[col] == 0
+              ? 0
+              : 0.9 + 0.1 * nsamplesup[col] / static_cast<double>(minreliable);
       cost = weightPs * pseudocostup[col];
       cost += (1.0 - weightPs) * getAvgPseudocost();
     } else
@@ -217,9 +218,10 @@ class HighsPseudocost {
     double cost;
 
     if (nsamplesdown[col] == 0 || nsamplesdown[col] < minreliable) {
-      double weightPs = nsamplesdown[col] == 0 ? 0
-                                               : 0.9 + 0.1 * nsamplesdown[col] /
-                                                           (double)minreliable;
+      double weightPs = nsamplesdown[col] == 0
+                            ? 0
+                            : 0.9 + 0.1 * nsamplesdown[col] /
+                                        static_cast<double>(minreliable);
       cost = weightPs * pseudocostdown[col];
       cost += (1.0 - weightPs) * getAvgPseudocost();
     } else
@@ -257,12 +259,15 @@ class HighsPseudocost {
 
     double cutOffScoreUp =
         ncutoffsup[col] /
-        std::max(1.0, double(ncutoffsup[col] + nsamplesup[col]));
+        std::max(1.0, static_cast<double>(ncutoffsup[col]) +
+                          static_cast<double>(nsamplesup[col]));
     double cutOffScoreDown =
         ncutoffsdown[col] /
-        std::max(1.0, double(ncutoffsdown[col] + nsamplesdown[col]));
-    double avgCutoffs =
-        ncutoffstotal / std::max(1.0, double(ncutoffstotal + nsamplestotal));
+        std::max(1.0, static_cast<double>(ncutoffsdown[col]) +
+                          static_cast<double>(nsamplesdown[col]));
+    double avgCutoffs = static_cast<double>(ncutoffstotal) /
+                        std::max(1.0, static_cast<double>(ncutoffstotal) +
+                                          static_cast<double>(nsamplestotal));
 
     double cutoffScore = std::max(cutOffScoreUp, 1e-6) *
                          std::max(cutOffScoreDown, 1e-6) /
@@ -271,7 +276,8 @@ class HighsPseudocost {
     double conflictScoreUp = conflictscoreup[col] / conflict_weight;
     double conflictScoreDown = conflictscoredown[col] / conflict_weight;
     double conflictScoreAvg =
-        conflict_avg_score / (conflict_weight * conflictscoreup.size());
+        conflict_avg_score /
+        (conflict_weight * static_cast<double>(conflictscoreup.size()));
     double conflictScore = std::max(conflictScoreUp, 1e-6) *
                            std::max(conflictScoreDown, 1e-6) /
                            std::max(1e-6, conflictScoreAvg * conflictScoreAvg);
@@ -297,15 +303,18 @@ class HighsPseudocost {
 
     double cutOffScoreUp =
         ncutoffsup[col] /
-        std::max(1.0, double(ncutoffsup[col] + nsamplesup[col]));
-    double avgCutoffs =
-        ncutoffstotal / std::max(1.0, double(ncutoffstotal + nsamplestotal));
+        std::max(1.0, static_cast<double>(ncutoffsup[col]) +
+                          static_cast<double>(nsamplesup[col]));
+    double avgCutoffs = static_cast<double>(ncutoffstotal) /
+                        std::max(1.0, static_cast<double>(ncutoffstotal) +
+                                          static_cast<double>(nsamplestotal));
 
     double cutoffScore = cutOffScoreUp / std::max(1e-6, avgCutoffs);
 
     double conflictScoreUp = conflictscoreup[col] / conflict_weight;
     double conflictScoreAvg =
-        conflict_avg_score / (conflict_weight * conflictscoreup.size());
+        conflict_avg_score /
+        (conflict_weight * static_cast<double>(conflictscoreup.size()));
     double conflictScore = conflictScoreUp / std::max(1e-6, conflictScoreAvg);
 
     auto mapScore = [](double score) { return 1.0 - 1.0 / (1.0 + score); };
@@ -323,15 +332,18 @@ class HighsPseudocost {
 
     double cutOffScoreDown =
         ncutoffsdown[col] /
-        std::max(1.0, double(ncutoffsdown[col] + nsamplesdown[col]));
-    double avgCutoffs =
-        ncutoffstotal / std::max(1.0, double(ncutoffstotal + nsamplestotal));
+        std::max(1.0, static_cast<double>(ncutoffsdown[col]) +
+                          static_cast<double>(nsamplesdown[col]));
+    double avgCutoffs = static_cast<double>(ncutoffstotal) /
+                        std::max(1.0, static_cast<double>(ncutoffstotal) +
+                                          static_cast<double>(nsamplestotal));
 
     double cutoffScore = cutOffScoreDown / std::max(1e-6, avgCutoffs);
 
     double conflictScoreDown = conflictscoredown[col] / conflict_weight;
     double conflictScoreAvg =
-        conflict_avg_score / (conflict_weight * conflictscoredown.size());
+        conflict_avg_score /
+        (conflict_weight * static_cast<double>(conflictscoredown.size()));
     double conflictScore = conflictScoreDown / std::max(1e-6, conflictScoreAvg);
 
     auto mapScore = [](double score) { return 1.0 - 1.0 / (1.0 + score); };

casadi/include/highs/mip/HighsRedcostFixing.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/mip/HighsSearch.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -96,6 +96,7 @@ class HighsSearch {
              std::shared_ptr<const StabilizerOrbits> stabilizerOrbits = nullptr)
         : lower_bound(parentlb),
           estimate(parentestimate),
+          branching_point(0.0),
           lp_objective(-kHighsInf),
           other_child_lb(parentlb),
           nodeBasis(std::move(parentBasis)),

casadi/include/highs/mip/HighsSeparation.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/mip/HighsSeparator.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/mip/HighsTableauSeparator.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/mip/HighsTransformedLp.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/model/HighsHessian.h

@@ -20,6 +20,7 @@
 
 #include "lp_data/HConst.h"
 #include "util/HighsCDouble.h"
+#include "util/HighsUtils.h"
 
 // class HighsHessian;
 
@@ -37,12 +38,16 @@ class HighsHessian {
   double objectiveValue(const std::vector<double>& solution) const;
   HighsCDouble objectiveCDoubleValue(const std::vector<double>& solution) const;
   void exactResize();
+  void deleteCols(const HighsIndexCollection& index_collection);
   void clear();
   bool formatOk() const {
     return (this->format_ == HessianFormat::kTriangular ||
             this->format_ == HessianFormat::kSquare);
   };
+  bool scaleOk(const HighsInt cost_scale, const double small_matrix_value,
+               const double large_matrix_value) const;
   HighsInt numNz() const;
+
   void print() const;
 };
 

casadi/include/highs/model/HighsHessianUtils.h

@@ -41,6 +41,8 @@ HighsStatus extractTriangularHessian(const HighsOptions& options,
 void triangularToSquareHessian(const HighsHessian& hessian,
                                vector<HighsInt>& start, vector<HighsInt>& index,
                                vector<double>& value);
+void completeHessian(const HighsInt full_dim, HighsHessian& hessian);
+
 void reportHessian(const HighsLogOptions& log_options, const HighsInt dim,
                    const HighsInt num_nz, const HighsInt* start,
                    const HighsInt* index, const double* value);

casadi/include/highs/model/HighsModel.h

@@ -29,11 +29,20 @@ class HighsModel {
   HighsHessian hessian_;
   bool operator==(const HighsModel& model) const;
   bool equalButForNames(const HighsModel& model) const;
-  bool isQp() const { return this->hessian_.dim_; }
+  bool isQp() const { return (this->hessian_.dim_ != 0); }
   bool isMip() const { return this->lp_.isMip(); }
   bool isEmpty() const {
     return (this->lp_.num_col_ == 0 && this->lp_.num_row_ == 0);
   }
+  bool needsMods(const double infinite_cost) const {
+    return this->lp_.needsMods(infinite_cost);
+  }
+  bool hasMods() const { return this->lp_.hasMods(); }
+  bool userCostScaleOk(const HighsInt user_cost_scale,
+                       const double small_matrix_value,
+                       const double large_matrix_value,
+                       const double infinite_cost) const;
+  void userCostScale(const HighsInt user_cost_scale);
   void clear();
   double objectiveValue(const std::vector<double>& solution) const;
   void objectiveGradient(const std::vector<double>& solution,

casadi/include/highs/parallel/HighsMutex.h

@@ -114,7 +114,8 @@ class HighsMutex {
   }
 
   void unlock() {
-    unsigned int prevState = state.fetch_add(-1, std::memory_order_release);
+    unsigned int prevState = state.fetch_add(
+        std::numeric_limits<unsigned int>::max(), std::memory_order_release);
 
     if (prevState != 1) {
       unsigned int notifyWorkerId = (prevState >> 1) - 1;

casadi/include/highs/parallel/HighsParallel.h

@@ -23,8 +23,13 @@ namespace parallel {
 using mutex = HighsMutex;
 
 inline void initialize_scheduler(int numThreads = 0) {
-  if (numThreads == 0)
+  if (numThreads == 0) {
+#ifdef HIGHS_NO_DEFAULT_THREADS
+    numThreads = 1;
+#else
     numThreads = (std::thread::hardware_concurrency() + 1) / 2;
+#endif
+  }
   HighsTaskExecutor::initialize(numThreads);
 }
 
@@ -125,4 +130,4 @@ void for_each(HighsInt start, HighsInt end, F&& f, HighsInt grainSize = 1) {
 
 }  // namespace highs
 
-#endif
+#endif

casadi/include/highs/parallel/HighsTask.h

@@ -109,8 +109,7 @@ class HighsTask {
   }
 
   void cancel() {
-    uintptr_t state =
-        metadata.stealer.fetch_or(kCancelFlag, std::memory_order_release);
+    metadata.stealer.fetch_or(kCancelFlag, std::memory_order_release);
   }
 
   /// run task as owner, if not cancelled

casadi/include/highs/pdlp/CupdlpWrapper.h

@@ -0,0 +1,93 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file pdlp/CupdlpWrapper.h
+ * @brief
+ */
+#ifndef PDLP_CUPDLP_WRAPPER_H_
+#define PDLP_CUPDLP_WRAPPER_H_
+
+#include <algorithm>
+#include <cassert>
+
+#include "lp_data/HighsSolution.h"
+#include "pdlp/cupdlp/cupdlp.h"
+
+typedef enum CONSTRAINT_TYPE { EQ = 0, LEQ, GEQ, BOUND } constraint_type;
+
+#define cupdlp_init_int(var, size) \
+  { (var) = (int*)malloc((size) * sizeof(int)); }
+
+#define cupdlp_init_double(var, size) \
+  { (var) = (double*)malloc((size) * sizeof(double)); }
+
+#define cupdlp_init_work(var, size) \
+  { (var) = (CUPDLPwork*)malloc((size) * sizeof(CUPDLPwork)); }
+
+#define cupdlp_init_problem(var, size) \
+  { (var) = (CUPDLPproblem*)malloc((size) * sizeof(CUPDLPproblem)); }
+
+#define cupdlp_init_data(var, size) \
+  { (var) = (CUPDLPdata*)malloc((size) * sizeof(CUPDLPdata)); }
+
+#define cupdlp_init_vec_double(var, size) \
+  { (var) = (double*)malloc((size) * sizeof(double)); }
+
+#define cupdlp_init_zero_vec_double(var, size) \
+  { (var) = (double*)calloc(size, sizeof(double)); }
+
+#define cupdlp_copy_vec(dst, src, type, size) \
+  memcpy(dst, src, sizeof(type) * (size))
+
+//#define cupdlp_init_csc_cpu(var, size)	\
+//   {\
+//     (var) = (CUPDLPcsc*)malloc((size) * sizeof(CUPDLPcsc));\
+//   }
+
+cupdlp_retcode problem_create(CUPDLPproblem** prob);
+// cupdlp_retcode csc_create(CUPDLPcsc **csc_cpu);
+
+cupdlp_retcode problem_alloc(
+    CUPDLPproblem* prob, cupdlp_int nRows, cupdlp_int nCols, cupdlp_int nEqs,
+    cupdlp_float* cost, cupdlp_float offset, cupdlp_float sign_origin,
+    void* matrix, CUPDLP_MATRIX_FORMAT src_matrix_format,
+    CUPDLP_MATRIX_FORMAT dst_matrix_format, cupdlp_float* rhs,
+    cupdlp_float* lower, cupdlp_float* upper, cupdlp_float* alloc_matrix_time,
+    cupdlp_float* copy_vec_time);
+
+cupdlp_retcode data_alloc(CUPDLPdata* data, cupdlp_int nRows, cupdlp_int nCols,
+                          void* matrix, CUPDLP_MATRIX_FORMAT src_matrix_format,
+                          CUPDLP_MATRIX_FORMAT dst_matrix_format);
+
+double infNorm(double* x, cupdlp_int n);
+
+void cupdlp_haslb(cupdlp_float* haslb, const cupdlp_float* lb,
+                  const cupdlp_float bound, const cupdlp_int len);
+
+void cupdlp_hasub(cupdlp_float* hasub, const cupdlp_float* ub,
+                  const cupdlp_float bound, const cupdlp_int len);
+
+HighsStatus solveLpCupdlp(HighsLpSolverObject& solver_object);
+
+HighsStatus solveLpCupdlp(const HighsOptions& options, HighsTimer& timer,
+                          const HighsLp& lp, HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& callback);
+int formulateLP_highs(const HighsLp& lp, double** cost, int* nCols, int* nRows,
+                      int* nnz, int* nEqs, int** csc_beg, int** csc_idx,
+                      double** csc_val, double** rhs, double** lower,
+                      double** upper, double* offset, double* sign_origin,
+                      int* nCols_origin, int** constraint_new_idx,
+                      int* constraint_type);
+
+cupdlp_int getCupdlpLogLevel(const HighsOptions& options);
+
+#endif

casadi/include/highs/pdlp/cupdlp/cupdlp_cs.h

@@ -0,0 +1,41 @@
+#ifndef CUPDLP_CS_H
+#define CUPDLP_CS_H
+
+#include "cupdlp_defs.h"
+
+/* sparse matrix in column-oriented form used in reading mps*/
+typedef struct cupdlp_cs_sparse {
+  int nzmax;
+  int m;     /* number of rows */
+  int n;     /* number of columns */
+  int *p;    /* column pointers (size n+1) or col indices (size nzmax) */
+  int *i;    /* row indices, size nzmax */
+  double *x; /* numerical values, size nzmax */
+  int nz;    /* # of entries in triplet matrix, -1 for compressed-col */
+} cupdlp_dcs;
+
+int cupdlp_dcs_entry(cupdlp_dcs *T, int i, int j, double x);
+cupdlp_dcs *cupdlp_dcs_compress(const cupdlp_dcs *T);
+double cupdlp_dcs_norm(const cupdlp_dcs *A);
+int cupdlp_dcs_print(const cupdlp_dcs *A, int brief);
+
+/* utilities */
+void *_dcs_calloc(int n, size_t size);
+void *cupdlp_dcs_free(void *p);
+void *cupdlp_dcs_realloc(void *p, int n, size_t size, int *ok);
+cupdlp_dcs *cupdlp_dcs_spalloc(int m, int n, int nzmax, int values, int t);
+cupdlp_dcs *cupdlp_dcs_spfree(cupdlp_dcs *A);
+int cupdlp_dcs_sprealloc(cupdlp_dcs *A, int nzmax);
+void *cupdlp_dcs_malloc(int n, size_t size);
+
+/* utilities */
+double cupdlp_dcs_cumsum(int *p, int *c, int n);
+cupdlp_dcs *cupdlp_dcs_done(cupdlp_dcs *C, void *w, void *x, int ok);
+int *cupdlp_dcs_idone(int *p, cupdlp_dcs *C, void *w, int ok);
+cupdlp_dcs *cupdlp_dcs_transpose(const cupdlp_dcs *A, int values);
+
+#define IS_CSC(A) (A && (A->nz == -1))
+#define IS_TRIPLET(A) (A && (A->nz >= 0))
+/*--------------------------------------------------------------------------*/
+
+#endif