casadi 3.6.5__cp38-none-manylinux2014_i686.whl → 3.6.7__cp38-none-manylinux2014_i686.whl

casadi/include/highs/qpsolver/pricing.hpp

@@ -0,0 +1,15 @@
+#ifndef __SRC_LIB_PRICING_HPP__
+#define __SRC_LIB_PRICING_HPP__
+
+#include "qpvector.hpp"
+
+class Pricing {
+ public:
+  virtual HighsInt price(const QpVector& x, const QpVector& gradient) = 0;
+  virtual void update_weights(const QpVector& aq, const QpVector& ep, HighsInt p,
+                              HighsInt q) = 0;
+  virtual void recompute() = 0;
+  virtual ~Pricing() {}
+};
+
+#endif

casadi/include/highs/qpsolver/qpconst.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#ifndef __SRC_LIB_QPCONST_HPP__
+#define __SRC_LIB_QPCONST_HPP__
+
+enum class QpSolverStatus { OK, NOTPOSITIVDEFINITE, DEGENERATE };
+
+enum class QpModelStatus {
+  kNotset, // 0
+  kUndetermined,
+  kOptimal,
+  kUnbounded,
+  kInfeasible,
+  kIterationLimit,
+  kTimeLimit,
+  kLargeNullspace,
+  kError
+};
+
+enum class BasisStatus {
+  kInactive,
+  kActiveAtLower = 1,
+  kActiveAtUpper,
+  kInactiveInBasis
+};
+
+
+#endif

casadi/include/highs/qpsolver/{vector.hpp → qpvector.hpp}

@@ -8,19 +8,19 @@
 #include <string>
 #include <vector>
 
-struct Vector {
+struct QpVector {
   HighsInt num_nz;
   HighsInt dim;
   std::vector<HighsInt> index;
   std::vector<double> value;
 
-  Vector(HighsInt d) : dim(d) {
+  QpVector(HighsInt d) : dim(d) {
     index.resize(dim);
     value.resize(dim, 0.0);
     num_nz = 0;
   }
 
-  Vector(const Vector& vec)
+  QpVector(const QpVector& vec)
       : num_nz(vec.num_nz), dim(vec.dim), index(vec.index), value(vec.value) {}
 
   void reset() {
@@ -31,7 +31,7 @@ struct Vector {
     num_nz = 0;
   }
 
-  Vector& repopulate(const Vector& other) {
+  QpVector& repopulate(const QpVector& other) {
     reset();
     for (HighsInt i = 0; i < other.num_nz; i++) {
       index[i] = other.index[i];
@@ -41,7 +41,7 @@ struct Vector {
     return *this;
   }
 
-  Vector& operator=(const Vector& other) {
+  QpVector& operator=(const QpVector& other) {
     num_nz = other.num_nz;
     dim = other.dim;
     index = other.index;
@@ -49,7 +49,7 @@ struct Vector {
     return *this;
   }
 
-  static Vector& unit(HighsInt dim, HighsInt u, Vector& target) {
+  static QpVector& unit(HighsInt dim, HighsInt u, QpVector& target) {
     target.reset();
     target.index[0] = u;
     target.value[u] = 1.0;
@@ -57,15 +57,15 @@ struct Vector {
     return target;
   }
 
-  static Vector unit(HighsInt dim, HighsInt u) {
-    Vector vec(dim);
+  static QpVector unit(HighsInt dim, HighsInt u) {
+    QpVector vec(dim);
     vec.index[0] = u;
     vec.value[u] = 1.0;
     vec.num_nz = 1;
     return vec;
   }
 
-  void report(std::string name = "") {
+  void report(std::string name = "") const {
     if (name != "") {
       printf("%s: ", name.c_str());
     }
@@ -85,7 +85,7 @@ struct Vector {
     return val;
   }
 
-  void sanitize(double threshold = 10E-15) {
+  void sanitize(double threshold = 1e-14) {
     HighsInt new_idx = 0;
 
     for (HighsInt i = 0; i < num_nz; i++) {
@@ -108,20 +108,20 @@ struct Vector {
     }
   }
 
-  Vector& scale(double a) {
+  QpVector& scale(double a) {
     for (HighsInt i = 0; i < num_nz; i++) {
       value[index[i]] *= a;
     }
     return *this;
   }
 
-  Vector& saxpy(double a, double b, const Vector& x) {
+  QpVector& saxpy(double a, double b, const QpVector& x) {
     scale(a);
     saxpy(b, x);
     return *this;
   }
 
-  Vector& saxpy(double a, const Vector& x) {
+  QpVector& saxpy(double a, const QpVector& x) {
     sanitize(0.0);
     for (HighsInt i = 0; i < x.num_nz; i++) {
       if (value[x.index[i]] == 0.0) {
@@ -141,8 +141,8 @@ struct Vector {
   //    resparsify();
   // }
 
-  Vector operator+(const Vector& other) const {
-    Vector result(dim);
+  QpVector operator+(const QpVector& other) const {
+    QpVector result(dim);
 
     for (HighsInt i = 0; i < dim; i++) {
       result.value[i] = value[i] + other.value[i];
@@ -154,8 +154,8 @@ struct Vector {
     return result;
   }
 
-  Vector operator-(const Vector& other) const {
-    Vector result(dim);
+  QpVector operator-(const QpVector& other) const {
+    QpVector result(dim);
 
     for (HighsInt i = 0; i < dim; i++) {
       result.value[i] = value[i] - other.value[i];
@@ -167,8 +167,8 @@ struct Vector {
     return result;
   }
 
-  Vector operator-() const {
-    Vector result(dim);
+  QpVector operator-() const {
+    QpVector result(dim);
 
     for (HighsInt i = 0; i < num_nz; i++) {
       result.index[i] = index[i];
@@ -179,8 +179,8 @@ struct Vector {
     return result;
   }
 
-  Vector operator*(const double d) const {
-    Vector result(dim);
+  QpVector operator*(const double d) const {
+    QpVector result(dim);
 
     for (HighsInt i = 0; i < num_nz; i++) {
       result.index[i] = index[i];
@@ -191,7 +191,7 @@ struct Vector {
     return result;
   }
 
-  double dot(const Vector& other) const {
+  double dot(const QpVector& other) const {
     double dot = 0.0;
     for (HighsInt i = 0; i < num_nz; i++) {
       dot += value[index[i]] * other.value[index[i]];
@@ -200,7 +200,7 @@ struct Vector {
     return dot;
   }
 
-  double operator*(const Vector& other) const { return dot(other); }
+  double operator*(const QpVector& other) const { return dot(other); }
 
   double dot(const HighsInt* idx, const double* val, HighsInt nnz) const {
     double dot = 0.0;
@@ -211,7 +211,7 @@ struct Vector {
     return dot;
   }
 
-  Vector& operator+=(const Vector& other) {
+  QpVector& operator+=(const QpVector& other) {
     // sanitize();
     for (HighsInt i = 0; i < other.num_nz; i++) {
       // if (value[other.index[i]] == 0.0) {
@@ -223,7 +223,7 @@ struct Vector {
     return *this;
   }
 
-  Vector& operator*=(const double d) {
+  QpVector& operator*=(const double d) {
     for (HighsInt i = 0; i < num_nz; i++) {
       value[index[i]] *= d;
     }

casadi/include/highs/qpsolver/quass.hpp

@@ -10,7 +10,7 @@
 struct Quass {
   Quass(Runtime& rt);
 
-  void solve(const Vector& x0, const Vector& ra, Basis& b0, HighsTimer& timer);
+  void solve(const QpVector& x0, const QpVector& ra, Basis& b0, HighsTimer& timer);
 
  private:
   Runtime& runtime;

casadi/include/highs/qpsolver/ratiotest.hpp

@@ -0,0 +1,19 @@
+#ifndef __SRC_LIB_RATIOTEST_HPP__
+#define __SRC_LIB_RATIOTEST_HPP__
+
+#include <limits>
+
+#include "runtime.hpp"
+
+struct RatiotestResult {
+  double alpha;
+  HighsInt limitingconstraint;
+  bool nowactiveatlower;
+};
+
+RatiotestResult ratiotest(Runtime& runtime, const QpVector& p,
+                          const QpVector& rowmove, double alphastart);
+
+Instance ratiotest_relax_instance(Runtime& runtime);
+
+#endif

casadi/include/highs/qpsolver/runtime.hpp

@@ -0,0 +1,38 @@
+#ifndef __SRC_LIB_RUNTIME_HPP__
+#define __SRC_LIB_RUNTIME_HPP__
+
+#include "util/HighsTimer.h"
+#include "instance.hpp"
+#include "settings.hpp"
+#include "statistics.hpp"
+#include "qpsolver/qpconst.hpp"
+
+struct Runtime {
+  Instance instance;
+  Instance relaxed_for_ratiotest;
+  Instance scaled;
+  Instance perturbed;
+  Settings settings;
+  Statistics& statistics;
+
+  QpVector primal;
+  QpVector rowactivity;
+  QpVector dualvar;
+  QpVector dualcon;
+  QpModelStatus status = QpModelStatus::kUndetermined;
+
+  std::vector<BasisStatus> status_var;
+  std::vector<BasisStatus> status_con;
+
+  Runtime(Instance& inst, Statistics& stats)
+      : instance(inst),
+        statistics(stats),
+        primal(QpVector(instance.num_var)),
+        rowactivity(QpVector(instance.num_con)),
+        dualvar(instance.num_var),
+        dualcon(instance.num_con),
+        status_var(instance.num_var),
+        status_con(instance.num_con) {}
+};
+
+#endif

casadi/include/highs/qpsolver/settings.hpp

@@ -0,0 +1,57 @@
+#ifndef __SRC_LIB_SETTINGS_HPP__
+#define __SRC_LIB_SETTINGS_HPP__
+
+#include "eventhandler.hpp"
+#include "qpconst.hpp"
+#include "statistics.hpp"
+
+enum class RatiotestStrategy { TwoPass, Textbook };
+
+enum class PricingStrategy { SteepestEdge, DantzigWolfe, Devex };
+
+enum class Phase1Strategy { HIGHS, QUASS, BOUNDED };
+
+struct Settings {
+  RatiotestStrategy ratiotest = RatiotestStrategy::TwoPass;
+  double ratiotest_t = 1e-9;
+  double ratiotest_d = 1e-8;
+
+  PricingStrategy pricing = PricingStrategy::Devex;
+
+  double pnorm_zero_threshold = 1e-11; // if ||p|| < this threshold, p is determined to not be an improving search direction
+  double improvement_zero_threshold = 1e-4; // if p^t gradient < this threshold, p is determined to not be an improving search direction
+  double d_zero_threshold = 1e-12; // minimal value for pivot, will declare degeneracy if no larger pivot is found
+  double lambda_zero_threshold = 1e-9; // used for pricing / optimality checking
+  double pQp_zero_threshold = 1e-7; // if p'Qp < this, p is determined to not have curvature, a simplex-like iteration is performed.
+
+  bool hessianregularization = false; // if true, a small multiple of the identity matrix will be added to the Hessian
+  double hessianregularizationfactor = 1e-7; // multiple of identity matrix added to hessian in case of regularization
+
+  Phase1Strategy phase1strategy = Phase1Strategy::HIGHS;
+  bool phase1movefreevarsbasic = false;
+  bool phase1boundfreevars = false;
+
+  HighsInt reportingfequency = 1;
+  Eventhandler<Statistics&> iteration_log;
+  Eventhandler<QpModelStatus&> qp_model_status_log;
+  Eventhandler<HighsInt&> nullspace_limit_log;
+
+  HighsInt nullspace_limit = 4000;
+  
+  HighsInt reinvertfrequency = 1000;
+  HighsInt gradientrecomputefrequency = 100;
+  HighsInt reducedgradientrecomputefrequency =
+      std::numeric_limits<HighsInt>::infinity();
+  HighsInt reducedhessianrecomputefrequency =
+      std::numeric_limits<HighsInt>::infinity();
+
+  HighsInt iteration_limit = std::numeric_limits<HighsInt>::infinity();
+  double time_limit = std::numeric_limits<double>::infinity();
+
+  bool rowscaling = true;
+  bool varscaling = true;
+
+  bool perturbation = false;
+};
+
+#endif

casadi/include/highs/qpsolver/snippets.hpp

@@ -0,0 +1,29 @@
+#ifndef __SRC_LIB_SNIPPETS_HPP__
+#define __SRC_LIB_SNIPPETS_HPP__
+
+#include <algorithm>
+#include <vector>
+
+template <typename T>
+bool contains(const std::vector<T>& vec, const T& element) {
+  return std::find(vec.begin(), vec.end(), element) != vec.end();
+}
+
+template <typename T>
+bool remove(std::vector<T>& vec, const T& element) {
+  auto rem = std::remove(vec.begin(), vec.end(), element);
+  auto rem2 = vec.erase(rem, vec.end());
+  return rem2 != vec.end();
+}
+
+template <typename T>
+HighsInt indexof(const std::vector<T>& vec, const T& element) {
+  auto it = std::find(vec.begin(), vec.end(), element);
+  if (it != vec.end()) {
+    return distance(vec.begin(), it);
+  } else {
+    return -1;
+  }
+}
+
+#endif

casadi/include/highs/qpsolver/statistics.hpp

@@ -0,0 +1,23 @@
+#ifndef __SRC_LIB_STATISTICS_HPP__
+#define __SRC_LIB_STATISTICS_HPP__
+
+#include <chrono>
+#include <vector>
+
+struct Statistics {
+  HighsInt phase1_iterations = 0;
+  HighsInt num_iterations = 0;
+  std::chrono::high_resolution_clock::time_point time_start;
+  std::chrono::high_resolution_clock::time_point time_end;
+
+  std::vector<HighsInt> iteration;
+  std::vector<HighsInt> nullspacedimension;
+  std::vector<double> objval;
+  std::vector<double> time;
+  std::vector<double> sum_primal_infeasibilities;
+  std::vector<HighsInt> num_primal_infeasibilities;
+  std::vector<double> density_nullspace;
+  std::vector<double> density_factor;
+};
+
+#endif

casadi/include/highs/qpsolver/steepestedgepricing.hpp

@@ -0,0 +1,167 @@
+#ifndef __SRC_LIB_PRICING_STEEPESTEDGEPRICING_HPP__
+#define __SRC_LIB_PRICING_STEEPESTEDGEPRICING_HPP__
+
+#include "qpsolver/basis.hpp"
+#include "qpsolver/pricing.hpp"
+#include "qpsolver/runtime.hpp"
+
+//
+
+class SteepestEdgePricing : public Pricing {
+ private:
+  Runtime& runtime;
+  Basis& basis;
+  ReducedCosts& redcosts;
+  std::vector<double> weights;
+
+  HighsInt chooseconstrainttodrop(const QpVector& lambda) {
+    auto active_constraint_index = basis.getactive();
+    auto constraintindexinbasisfactor = basis.getindexinfactor();
+
+    HighsInt minidx = -1;
+    double maxval = 0.0;
+    for (size_t i = 0; i < active_constraint_index.size(); i++) {
+      HighsInt indexinbasis =
+          constraintindexinbasisfactor[active_constraint_index[i]];
+      if (indexinbasis == -1) {
+        printf("error\n");
+      }
+      assert(indexinbasis != -1);
+
+      double val = lambda.value[indexinbasis] * lambda.value[indexinbasis] /
+                   weights[indexinbasis];
+      if (val > maxval && fabs(lambda.value[indexinbasis]) >
+                              runtime.settings.lambda_zero_threshold) {
+        if (basis.getstatus(active_constraint_index[i]) ==
+                BasisStatus::kActiveAtLower &&
+            -lambda.value[indexinbasis] > 0) {
+          minidx = active_constraint_index[i];
+          maxval = val;
+        } else if (basis.getstatus(active_constraint_index[i]) ==
+                       BasisStatus::kActiveAtUpper &&
+                   lambda.value[indexinbasis] > 0) {
+          minidx = active_constraint_index[i];
+          maxval = val;
+        } else {
+          // TODO
+        }
+      }
+    }
+
+    return minidx;
+  }
+
+ public:
+  SteepestEdgePricing(Runtime& rt, Basis& bas, ReducedCosts& rc)
+      : runtime(rt),
+        basis(bas),
+        redcosts(rc),
+        weights(std::vector<double>(rt.instance.num_var, 1.0)) {
+          compute_exact_weights();
+        };
+
+  HighsInt price(const QpVector& x, const QpVector& gradient) {
+    HighsInt minidx = chooseconstrainttodrop(redcosts.getReducedCosts());
+    return minidx;
+  }
+
+
+  double compute_exact_weight(HighsInt i) {
+    QpVector y_i = basis.btran(QpVector::unit(runtime.instance.num_var, i));
+    return y_i.dot(y_i);
+  }
+
+  void compute_exact_weights() {
+    for (int i=0; i<runtime.instance.num_var; i++) {
+      weights[i] = compute_exact_weight(i);
+    }
+  }
+
+  bool check_weight(HighsInt i) {
+    double weight_is = weights[i];
+    double weight_comp = compute_exact_weight(i);
+    if(fabs(weight_comp - weight_is) > 1e-2) {
+      //printf("weights[%d] = %lf, should be %lf\n", i, weight_is, weight_comp);
+      return false;
+    }
+    return true;
+  }
+
+  bool check_weights() {
+
+    std::vector<int> correct_weights;
+    std::vector<int> incorrect_weights;
+    for (int i=0; i<runtime.instance.num_var; i++) {
+      bool correct = check_weight(i);
+        if (correct) {
+          correct_weights.push_back(i);
+        } else {
+          incorrect_weights.push_back(i);
+        }
+    }
+
+    printf("correct weights: ");
+    for (int& i : correct_weights) {
+      printf("%d ", i);
+    }
+    printf("\n");
+
+    printf("incorrect weights: ");
+    for (int& i : incorrect_weights) {
+      printf("%d ", i);
+    }
+    printf("\n");
+
+    return incorrect_weights.size() == 0;
+    }
+
+  void recompute() {
+    compute_exact_weights();
+  }
+
+  void update_weights(const QpVector& aq, const QpVector& ep, HighsInt p,
+                      HighsInt q) {
+    HighsInt rowindex_p = basis.getindexinfactor()[p];
+    //printf("Update weights, p = %d, rowindex = %d, q = %d\n", p, rowindex_p, q);
+
+    //if (!check_weights()) {
+    //  printf("weight check failed\n");
+    //  exit(1);
+    //}
+
+    QpVector delta = basis.ftran(aq);
+
+    //double old_weight_p_updated = weights[rowindex_p];
+    // exact weight coming in needs to come in before update.
+    double old_weight_p_computed = ep.dot(ep);
+
+    //if (fabs(old_weight_p_computed - old_weight_p_updated) >= 1e-2) {
+    //  printf("old weight[p] discrepancy: updated = %lf, computed=%lf\n", old_weight_p_updated, old_weight_p_computed);
+    //}
+
+    double weight_p = old_weight_p_computed;
+
+    
+    double t_p = aq.value[rowindex_p];
+    for (HighsInt i = 0; i < runtime.instance.num_var; i++) {
+      if (i != rowindex_p) {
+        double t_i = aq.value[i];
+        weights[i] = weights[i]
+                    - 2 * (t_i / t_p) * delta.value[i]
+                    + ((t_i * t_i) / (t_p * t_p)) * weight_p;
+        //printf("weights[%d] = %lf\n", i, weights[i]);
+      }
+    }
+    //QpVector new_ep = basis.btran(QpVector::unit(runtime.instance.num_var, rowindex_p)); 
+    //double computed_weight = new_ep.dot(new_ep);
+    double new_weight_p_updated = weight_p / (t_p * t_p);
+    
+    //if (fabs(updated_weight - computed_weight) > 1e-4) {
+    //  printf("updated weight %lf vs computed weight %lf. aq[p] = %lf\n", updated_weight, computed_weight, t_p);
+    //  printf("old weight = %lf, aq[p] = %lf, ^2 = %lf, new weight = %lf\n", weight_p, t_p, t_p*t_p, updated_weight);
+    //}
+    weights[rowindex_p] = new_weight_p_updated;
+  }
+};
+
+#endif

casadi/include/highs/simplex/HApp.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/simplex/HEkk.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                     */
@@ -25,7 +25,41 @@ class HighsLpSolverObject;
 
 class HEkk {
  public:
-  HEkk() {}
+  HEkk()
+      : callback_(nullptr),
+        options_(nullptr),
+        timer_(nullptr),
+        lp_name_(""),
+        model_status_(HighsModelStatus::kNotset),
+        simplex_in_scaled_space_(false),
+        cost_scale_(1.0),
+        cost_perturbation_base_(0.0),
+        cost_perturbation_max_abs_cost_(0.0),
+        iteration_count_(0),
+        dual_simplex_cleanup_level_(0),
+        dual_simplex_phase1_cleanup_level_(0),
+        previous_iteration_cycling_detected(-kHighsIInf),
+        solve_bailout_(false),
+        called_return_from_solve_(false),
+        exit_algorithm_(SimplexAlgorithm::kNone),
+        return_primal_solution_status_(0),
+        return_dual_solution_status_(0),
+        original_num_col_(0),
+        original_num_row_(0),
+        original_num_nz_(0),
+        original_offset_(0.0),
+        edge_weight_error_(0.0),
+        build_synthetic_tick_(0.0),
+        total_synthetic_tick_(0.0),
+        debug_solve_call_num_(0),
+        debug_basis_id_(0),
+        time_report_(false),
+        debug_initial_build_synthetic_tick_(0),
+        debug_solve_report_(false),
+        debug_iteration_report_(false),
+        debug_basis_report_(false),
+        debug_dual_feasible(false),
+        debug_max_relative_dual_steepest_edge_weight_error(0) {}
   /**
    * @brief Interface to simplex solvers
    */
@@ -155,14 +189,14 @@ class HEkk {
   HSimplexNla simplex_nla_;
   HotStart hot_start_;
 
-  double cost_scale_ = 1;
+  double cost_scale_;
   double cost_perturbation_base_;
   double cost_perturbation_max_abs_cost_;
-  HighsInt iteration_count_ = 0;
-  HighsInt dual_simplex_cleanup_level_ = 0;
-  HighsInt dual_simplex_phase1_cleanup_level_ = 0;
+  HighsInt iteration_count_;
+  HighsInt dual_simplex_cleanup_level_;
+  HighsInt dual_simplex_phase1_cleanup_level_;
 
-  HighsInt previous_iteration_cycling_detected = -kHighsIInf;
+  HighsInt previous_iteration_cycling_detected;
 
   bool solve_bailout_;
   bool called_return_from_solve_;
@@ -197,17 +231,17 @@ class HEkk {
 
   double edge_weight_error_;
 
-  double build_synthetic_tick_ = 0;
-  double total_synthetic_tick_ = 0;
-  HighsInt debug_solve_call_num_ = 0;
-  HighsInt debug_basis_id_ = 0;
-  bool time_report_ = false;
-  HighsInt debug_initial_build_synthetic_tick_ = 0;
-  bool debug_solve_report_ = false;
-  bool debug_iteration_report_ = false;
-  bool debug_basis_report_ = false;
-  bool debug_dual_feasible = false;
-  double debug_max_relative_dual_steepest_edge_weight_error = 0;
+  double build_synthetic_tick_;
+  double total_synthetic_tick_;
+  HighsInt debug_solve_call_num_;
+  HighsInt debug_basis_id_;
+  bool time_report_;
+  HighsInt debug_initial_build_synthetic_tick_;
+  bool debug_solve_report_;
+  bool debug_iteration_report_;
+  bool debug_basis_report_;
+  bool debug_dual_feasible;
+  double debug_max_relative_dual_steepest_edge_weight_error;
 
   std::vector<HighsSimplexBadBasisChangeRecord> bad_basis_change_;
 

casadi/include/highs/simplex/HEkkDual.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                     */