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

casadi/include/highs/qpsolver/a_asm.hpp

@@ -0,0 +1,56 @@
+#ifndef __SRC_LIB_QPSOLVER_ASM_HPP__
+#define __SRC_LIB_QPSOLVER_ASM_HPP__
+
+#include "qpsolver/instance.hpp"
+#include "qpsolver/statistics.hpp"
+#include "qpsolver/qpconst.hpp"
+#include "qpsolver/settings.hpp"
+#include "util/HighsTimer.h"
+
+enum class QpAsmStatus {
+  OK,
+  NEGATIVEEIGENVALUEINREDUCEDHESSIAN,
+  BASISRANKDEFICIENT
+};
+
+struct QpSolution {
+  Vector primal;
+  Vector rowactivity;
+  Vector dualvar;
+  Vector dualcon;
+
+  std::vector<BasisStatus> status_var;
+  std::vector<BasisStatus> status_con;
+
+  QpSolution(Instance& instance) : primal(Vector(instance.num_var)),
+        rowactivity(Vector(instance.num_con)),
+        dualvar(instance.num_var),
+        dualcon(instance.num_con),
+        status_var(instance.num_var),
+        status_con(instance.num_con) {}
+};
+
+
+struct QpHotstartInformation {
+  std::vector<HighsInt> active;
+  std::vector<HighsInt> inactive;
+  std::vector<BasisStatus> status;
+  Vector primal;
+  Vector rowact;
+
+  QpHotstartInformation(HighsInt num_var, HighsInt num_row)
+      : primal(Vector(num_var)), rowact(Vector(num_row)) {}
+};
+
+// the purpose of this is the pure algorithmic solution of a QP instance with given hotstart information.
+// scenarios: 
+// 1) start from a given phase1 solution
+// 2) start from a user-given hotstart solution
+// 3) start from a qp solution that was attained from a scaled instance and cleanup
+// 4) start from a qp solution that was attained from a perturbed instance and cleanup
+// 5) start from a qp solution and cleanup after recomputing basis and reduced hessian factorization
+
+
+QpAsmStatus solveqp_actual(Instance& instance, Settings& settings, QpHotstartInformation& startinfo, Statistics& stats, QpModelStatus& status, QpSolution& solution, HighsTimer& qp_timer);
+
+#endif

casadi/include/highs/qpsolver/a_quass.hpp

@@ -0,0 +1,12 @@
+#ifndef __SRC_LIB_QPSOLVER_QUASS_HPP__
+#define __SRC_LIB_QPSOLVER_QUASS_HPP__
+
+#include "qpsolver/instance.hpp"
+#include "qpsolver/qpconst.hpp"
+#include "qpsolver/a_asm.hpp"
+#include "qpsolver/settings.hpp"
+
+
+QpAsmStatus solveqp(Instance& instance, Settings& settings, Statistics& stats, QpModelStatus& modelstatus, QpSolution& solution, HighsTimer& qp_timer);
+
+#endif

casadi/include/highs/qpsolver/quass.hpp

@@ -10,14 +10,11 @@
 struct Quass {
   Quass(Runtime& rt);
 
-  void solve(const Vector& x0, const Vector& ra, Basis& b0);
-
-  void solve();
+  void solve(const Vector& x0, const Vector& ra, Basis& b0, HighsTimer& timer);
 
  private:
   Runtime& runtime;
 
-  void loginformation(Runtime& rt, Basis& basis, CholeskyFactor& factor);
 };
 
 #endif

casadi/include/highs/simplex/HApp.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 #ifndef SIMPLEX_HAPP_H_
 #define SIMPLEX_HAPP_H_
@@ -147,17 +145,17 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
         return returnFromSolveLpSimplex(solver_object, call_status);
       }
     } else {
-      // Starting from a logical basis, so consider dualising and/or
+      // Starting from a logical basis, so consider dualizing and/or
       // permuting the LP
-      if (options.simplex_dualise_strategy == kHighsOptionChoose ||
-          options.simplex_dualise_strategy == kHighsOptionOn) {
-        // Dualise unless we choose not to
-        bool dualise_lp = true;
-        if (options.simplex_dualise_strategy == kHighsOptionChoose) {
+      if (options.simplex_dualize_strategy == kHighsOptionChoose ||
+          options.simplex_dualize_strategy == kHighsOptionOn) {
+        // Dualize unless we choose not to
+        bool dualize_lp = true;
+        if (options.simplex_dualize_strategy == kHighsOptionChoose) {
           if (incumbent_lp.num_row_ < 10 * incumbent_lp.num_col_)
-            dualise_lp = false;
+            dualize_lp = false;
         }
-        if (dualise_lp) ekk_instance.dualise();
+        if (dualize_lp) ekk_instance.dualize();
       }
       if (options.simplex_permute_strategy == kHighsOptionChoose ||
           options.simplex_permute_strategy == kHighsOptionOn) {
@@ -186,9 +184,9 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
     return_status = ekk_instance.solve();
     solved_unscaled_lp = true;
     ekk_instance.unpermute();
-    ekk_instance.undualise();
+    ekk_instance.undualize();
     assert(!ekk_instance.status_.is_permuted &&
-           !ekk_instance.status_.is_dualised);
+           !ekk_instance.status_.is_dualized);
     if (options.cost_scale_factor) {
       double cost_scale_factor = pow(2.0, -options.cost_scale_factor);
       highsLogDev(options.log_options, HighsLogType::kInfo,
@@ -211,9 +209,9 @@ inline HighsStatus solveLpSimplex(HighsLpSolverObject& solver_object) {
       //
       return_status = ekk_instance.solve();
       ekk_instance.unpermute();
-      ekk_instance.undualise();
+      ekk_instance.undualize();
       assert(!ekk_instance.status_.is_permuted &&
-             !ekk_instance.status_.is_dualised);
+             !ekk_instance.status_.is_dualized);
       //
       if (options.cost_scale_factor) {
         double cost_scale_factor = pow(2.0, -options.cost_scale_factor);

casadi/include/highs/simplex/HEkk.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HEkk.h
  * @brief Primal simplex solver for HiGHS
@@ -16,6 +14,7 @@
 #ifndef SIMPLEX_HEKK_H_
 #define SIMPLEX_HEKK_H_
 
+#include "lp_data/HighsCallback.h"
 #include "simplex/HSimplexNla.h"
 #include "simplex/HighsSimplexAnalysis.h"
 #include "util/HSet.h"
@@ -33,7 +32,7 @@ class HEkk {
   void clear();
   void clearEkkLp();
   void clearEkkData();
-  void clearEkkDualise();
+  void clearEkkDualize();
   void clearEkkDualEdgeWeightData();
   void clearEkkPointers();
   void clearEkkDataInfo();
@@ -58,13 +57,14 @@ class HEkk {
   void ftran(HVector& rhs, const double expected_density);
 
   void moveLp(HighsLpSolverObject& solver_object);
-  void setPointers(HighsOptions* options, HighsTimer* timer);
+  void setPointers(HighsCallback* callback, HighsOptions* options,
+                   HighsTimer* timer);
   HighsSparseMatrix* getScaledAMatrixPointer();
   HighsScale* getScalePointer();
 
   void initialiseEkk();
-  HighsStatus dualise();
-  HighsStatus undualise();
+  HighsStatus dualize();
+  HighsStatus undualize();
   HighsStatus permute();
   HighsStatus unpermute();
   HighsStatus solve(const bool force_phase2 = false);
@@ -133,6 +133,7 @@ class HEkk {
   bool debugNlaScalingOk(const HighsLp& lp) const;
 
   // Data members
+  HighsCallback* callback_;
   HighsOptions* options_;
   HighsTimer* timer_;
   HighsSimplexAnalysis analysis_;
@@ -169,11 +170,11 @@ class HEkk {
   HighsInt return_primal_solution_status_;
   HighsInt return_dual_solution_status_;
 
-  // Data to be retained after proving primal infeasiblilty
+  // Data to be retained after proving primal infeasibility
   vector<HighsInt> proof_index_;
   vector<double> proof_value_;
 
-  // Data to be retained when dualising
+  // Data to be retained when dualizing
   HighsInt original_num_col_;
   HighsInt original_num_row_;
   HighsInt original_num_nz_;
@@ -293,7 +294,7 @@ class HEkk {
   void invalidatePrimalMaxSumInfeasibilityRecord();
   void invalidateDualInfeasibilityRecord();
   void invalidateDualMaxSumInfeasibilityRecord();
-  bool bailoutOnTimeIterations();
+  bool bailout();
   HighsStatus returnFromEkkSolve(const HighsStatus return_status);
   HighsStatus returnFromSolve(const HighsStatus return_status);
 

casadi/include/highs/simplex/HEkkDual.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HEkkDual.h
  * @brief Dual simplex solver for HiGHS

casadi/include/highs/simplex/HEkkDualRHS.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HEkkDualRHS.h
  * @brief Dual simplex optimality test for HiGHS
@@ -78,9 +76,10 @@ class HEkkDualRHS {
   );
 
   /**
-   * @brief Update the primal values by adding a multiple of a given std::vector
+   * @brief Update the primal values by adding a multiple of a given
+   * std::vector, returning false if infinite values are created
    */
-  void updatePrimal(
+  bool updatePrimal(
       HVector* column,  //!< Column to add into primal values
       double theta      //!< Multiple of column to add into primal values
   );

casadi/include/highs/simplex/HEkkDualRow.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HEkkDualRow.h
  * @brief Dual simplex ratio test for HiGHS

casadi/include/highs/simplex/HEkkPrimal.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HEkkPrimal.h
  * @brief Phase 2 primal simplex solver for HiGHS

casadi/include/highs/simplex/HSimplex.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HSimplex.h
  * @brief

casadi/include/highs/simplex/HSimplexDebug.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HSimplexDebug.h
  * @brief

casadi/include/highs/simplex/HSimplexNla.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HSimplexNla.h
  *

casadi/include/highs/simplex/HSimplexReport.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/HSimplexReport.h
  * @brief
@@ -21,6 +19,6 @@
 
 void reportSimplexPhaseIterations(const HighsLogOptions& log_options,
                                   const HighsInt iteration_count,
-                                  const HighsSimplexInfo& info,
+                                  HighsSimplexInfo& info,
                                   const bool initialise = false);
 #endif  // SIMPLEX_HSIMPLEXREPORT_H_

casadi/include/highs/simplex/HighsSimplexAnalysis.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/HighsSimplexAnalysis.h
  * @brief Analyse simplex iterations, both for run-time control and data

casadi/include/highs/simplex/SimplexConst.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/SimplexConst.h
  * @brief Constants for HiGHS simplex solvers
@@ -121,6 +119,7 @@ enum RebuildReason {
   kRebuildReasonPrimalInfeasibleInPrimalSimplex,  // 8
   kRebuildReasonChooseColumnFail,                 // 9
   kRebuildReasonForceRefactor,                    // 10
+  kRebuildReasonExcessivePrimalValue,             // 11
   kRebuildReasonCount
 };
 
@@ -168,7 +167,10 @@ const double kMinDualSteepestEdgeWeight = 1e-4;
 const HighsInt kNoRowSought = -2;
 const HighsInt kNoRowChosen = -1;
 
-const double minDualSteepestEdgeWeight = 1e-4;
+// Switch to use code to check that, unless the basis supplied by the
+// MIP solver was alien, the simplex solver starts from dual
+// feasibility.
+const bool kDebugMipNodeDualFeasible = false;
 
 enum class LpAction {
   kScale = 0,

casadi/include/highs/simplex/SimplexStruct.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file lp_data/SimplexStruct.h
  * @brief Structs for HiGHS simplex solvers
@@ -44,7 +42,7 @@ struct SimplexBasis {
 struct HighsSimplexStatus {
   // Status of LP solved by the simplex method and its data
   bool initialised_for_new_lp = false;
-  bool is_dualised = false;
+  bool is_dualized = false;
   bool is_permuted = false;
   bool initialised_for_solve = false;
   bool has_basis = false;      // The simplex LP has a valid simplex basis
@@ -221,6 +219,14 @@ struct HighsSimplexInfo {
   HighsInt primal_phase2_iteration_count = 0;
   HighsInt primal_bound_swap = 0;
 
+  // Starting values for use in reportSimplexPhaseIterations
+  HighsInt iteration_count0 = 0;
+  HighsInt dual_phase1_iteration_count0 = 0;
+  HighsInt dual_phase2_iteration_count0 = 0;
+  HighsInt primal_phase1_iteration_count0 = 0;
+  HighsInt primal_phase2_iteration_count0 = 0;
+  HighsInt primal_bound_swap0 = 0;
+
   HighsInt min_concurrency = 1;
   HighsInt num_concurrency = 1;
   HighsInt max_concurrency = kSimplexConcurrencyLimit;

casadi/include/highs/simplex/SimplexTimer.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file simplex/SimplexTimer.h
  * @brief Indices of simplex iClocks

casadi/include/highs/test/DevKkt.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file test/DevKkt.h
  * @brief

casadi/include/highs/test/KktCh2.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file test/KktChStep.h
  * @brief

casadi/include/highs/util/FactorTimer.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/FactorTimer.h
  * @brief Indices of factor iClocks

casadi/include/highs/util/HFactor.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HFactor.h
  * @brief Basis matrix factorization, update and solves for HiGHS

casadi/include/highs/util/HFactorConst.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HFactorConst.h
  * @brief Constants for basis matrix factorization, update and solves for HiGHS

casadi/include/highs/util/HFactorDebug.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HFactorDebug.h
  * @brief

casadi/include/highs/util/HSet.h

@@ -2,13 +2,11 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2022 at the University of Edinburgh    */
+/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
 /*                                                                       */
-/*    Authors: Julian Hall, Ivet Galabova, Leona Gottwald and Michael    */
-/*    Feldmeier                                                          */
-/*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 /**@file util/HSet.h
  * @brief Set structure for HiGHS.
@@ -42,7 +40,7 @@ class HSet {
   bool setup(const HighsInt size,  //!< Dimension of the set to be initialised
              const HighsInt max_entry,  //!< Maximum entry to be in the set.
              const bool output_flag = false,  //!< Option for output
-             FILE* log_file_stream = NULL,    //!< File stream for output
+             FILE* log_stream = NULL,         //!< File stream for output
              const bool debug = false,        //!< Debug mode
              const bool allow_assert = true   //!< Allow asserts in debug
   );