casadi 3.6.4__cp312-none-win_amd64.whl → 3.6.6__cp312-none-win_amd64.whl

casadi/include/highs/lp_data/HighsCallbackStruct.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                     */
@@ -16,21 +16,47 @@
 
 #include "util/HighsInt.h"
 
-struct HighsCallbackDataOut {
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Struct to handle callback output data
+ *
+ */
+typedef struct {
   int log_type;  // cast of HighsLogType
   double running_time;
   HighsInt simplex_iteration_count;
   HighsInt ipm_iteration_count;
+  HighsInt pdlp_iteration_count;
   double objective_function_value;
   int64_t mip_node_count;
   double mip_primal_bound;
   double mip_dual_bound;
   double mip_gap;
   double* mip_solution;
-};
+  HighsInt cutpool_num_col;
+  HighsInt cutpool_num_cut;
+  HighsInt cutpool_num_nz;
+  HighsInt* cutpool_start;
+  HighsInt* cutpool_index;
+  double* cutpool_value;
+  double* cutpool_lower;
+  double* cutpool_upper;
+} HighsCallbackDataOut;
 
-struct HighsCallbackDataIn {
+typedef struct {
   int user_interrupt;
-};
+} HighsCallbackDataIn;
+
+// Additional callback handling
+typedef void (*HighsCCallbackType)(int, const char*,
+                                   const HighsCallbackDataOut*,
+                                   HighsCallbackDataIn*, void*);
+
+#ifdef __cplusplus
+}
+#endif
 
 #endif /* LP_DATA_HIGHSCALLBACKSTRUCT_H_ */

casadi/include/highs/lp_data/HighsDebug.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/lp_data/HighsInfo.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                     */
@@ -138,6 +138,7 @@ struct HighsInfoStruct {
   HighsInt simplex_iteration_count;
   HighsInt ipm_iteration_count;
   HighsInt crossover_iteration_count;
+  HighsInt pdlp_iteration_count;
   HighsInt qp_iteration_count;
   HighsInt primal_solution_status;
   HighsInt dual_solution_status;
@@ -152,6 +153,8 @@ struct HighsInfoStruct {
   HighsInt num_dual_infeasibilities;
   double max_dual_infeasibility;
   double sum_dual_infeasibilities;
+  double max_complementarity_violation;
+  double sum_complementarity_violations;
 };
 
 class HighsInfo : public HighsInfoStruct {
@@ -192,7 +195,7 @@ class HighsInfo : public HighsInfoStruct {
 
  private:
   void deleteRecords() {
-    for (HighsUInt i = 0; i < records.size(); i++) delete records[i];
+    for (size_t i = 0; i < records.size(); i++) delete records[i];
   }
 
   void initRecords() {
@@ -216,6 +219,11 @@ class HighsInfo : public HighsInfoStruct {
                                    &crossover_iteration_count, 0);
     records.push_back(record_int);
 
+    record_int = new InfoRecordInt("pdlp_iteration_count",
+                                   "Iteration count for PDLP solver", advanced,
+                                   &pdlp_iteration_count, 0);
+    records.push_back(record_int);
+
     record_int =
         new InfoRecordInt("qp_iteration_count", "Iteration count for QP solver",
                           advanced, &qp_iteration_count, 0);
@@ -295,6 +303,16 @@ class HighsInfo : public HighsInfoStruct {
         "sum_dual_infeasibilities", "Sum of dual infeasibilities", advanced,
         &sum_dual_infeasibilities, 0);
     records.push_back(record_double);
+
+    record_double = new InfoRecordDouble(
+        "max_complementarity_violation", "Max complementarity violation",
+        advanced, &max_complementarity_violation, 0);
+    records.push_back(record_double);
+
+    record_double = new InfoRecordDouble(
+        "sum_complementarity_violations", "Sum of complementarity violations",
+        advanced, &sum_complementarity_violations, 0);
+    records.push_back(record_double);
   }
 
  public:

casadi/include/highs/lp_data/HighsInfoDebug.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/lp_data/HighsLp.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                     */
@@ -50,6 +50,8 @@ class HighsLp {
   HighsNameHash col_hash_;
   HighsNameHash row_hash_;
 
+  HighsInt user_bound_scale_;
+  HighsInt user_cost_scale_;
   HighsScale scale_;
   bool is_scaled_;
   bool is_moved_;
@@ -63,6 +65,8 @@ class HighsLp {
   bool isMip() const;
   bool hasSemiVariables() const;
   bool hasInfiniteCost(const double infinite_cost) const;
+  bool hasMods() const;
+  bool needsMods(const double infinite_cost) const;
   double objectiveValue(const std::vector<double>& solution) const;
   HighsCDouble objectiveCDoubleValue(const std::vector<double>& solution) const;
   void setMatrixDimensions();
@@ -75,9 +79,21 @@ class HighsLp {
   void applyScale();
   void unapplyScale();
   void moveBackLpAndUnapplyScaling(HighsLp& lp);
+  bool userBoundScaleOk(const HighsInt user_bound_scale,
+                        const double infinite_bound) const;
+  void userBoundScale(const HighsInt user_bound_scale);
+  bool userCostScaleOk(const HighsInt user_cost_scale,
+                       const double infinite_cost) const;
+  void userCostScale(const HighsInt user_cost_scale);
   void exactResize();
   void addColNames(const std::string name, const HighsInt num_new_col = 1);
   void addRowNames(const std::string name, const HighsInt num_new_row = 1);
+  void deleteColsFromVectors(HighsInt& new_num_col,
+                             const HighsIndexCollection& index_collection);
+  void deleteRowsFromVectors(HighsInt& new_num_row,
+                             const HighsIndexCollection& index_collection);
+  void deleteCols(const HighsIndexCollection& index_collection);
+  void deleteRows(const HighsIndexCollection& index_collection);
   void unapplyMods();
   void clear();
 };

casadi/include/highs/lp_data/HighsLpSolverObject.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/lp_data/HighsLpUtils.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                     */
@@ -57,8 +57,17 @@ HighsStatus assessBounds(const HighsOptions& options, const char* type,
 
 HighsStatus cleanBounds(const HighsOptions& options, HighsLp& lp);
 
-HighsStatus assessIntegrality(HighsLp& lp, const HighsOptions& options);
-void relaxSemiVariables(HighsLp& lp);
+bool boundScaleOk(const std::vector<double>& lower,
+                  const std::vector<double>& upper, const HighsInt bound_scale,
+                  const double infinite_bound);
+
+bool costScaleOk(const std::vector<double>& cost, const HighsInt cost_scale,
+                 const double infinite_cost);
+
+HighsStatus assessSemiVariables(HighsLp& lp, const HighsOptions& options,
+                                bool& made_semi_variable_mods);
+void relaxSemiVariables(HighsLp& lp, bool& made_semi_variable_mods);
+
 bool activeModifiedUpperBounds(const HighsOptions& options, const HighsLp& lp,
                                const std::vector<double> col_value);
 
@@ -76,6 +85,8 @@ HighsStatus applyScalingToLpCol(HighsLp& lp, const HighsInt col,
 HighsStatus applyScalingToLpRow(HighsLp& lp, const HighsInt row,
                                 const double rowScale);
 
+void unscaleSolution(HighsSolution& solution, const HighsScale& scale);
+
 void appendColsToLpVectors(HighsLp& lp, const HighsInt num_new_col,
                            const vector<double>& colCost,
                            const vector<double>& colLower,
@@ -85,16 +96,6 @@ void appendRowsToLpVectors(HighsLp& lp, const HighsInt num_new_row,
                            const vector<double>& rowLower,
                            const vector<double>& rowUpper);
 
-void deleteLpCols(HighsLp& lp, const HighsIndexCollection& index_collection);
-
-void deleteColsFromLpVectors(HighsLp& lp, HighsInt& new_num_col,
-                             const HighsIndexCollection& index_collection);
-
-void deleteLpRows(HighsLp& lp, const HighsIndexCollection& index_collection);
-
-void deleteRowsFromLpVectors(HighsLp& lp, HighsInt& new_num_row,
-                             const HighsIndexCollection& index_collection);
-
 void deleteScale(vector<double>& scale,
                  const HighsIndexCollection& index_collection);
 
@@ -229,15 +230,14 @@ HighsStatus assessLpPrimalSolution(const HighsOptions& options,
                                    const HighsSolution& solution, bool& valid,
                                    bool& integral, bool& feasible);
 
-HighsStatus calculateRowValues(const HighsLp& lp,
-                               const std::vector<double>& col_value,
-                               std::vector<double>& row_value);
-HighsStatus calculateRowValues(const HighsLp& lp, HighsSolution& solution);
+HighsStatus calculateRowValuesQuad(const HighsLp& lp,
+                                   const std::vector<double>& col_value,
+                                   std::vector<double>& row_value,
+                                   const HighsInt report_row = -1);
 HighsStatus calculateRowValuesQuad(const HighsLp& lp, HighsSolution& solution,
                                    const HighsInt report_row = -1);
-HighsStatus calculateColDuals(const HighsLp& lp, HighsSolution& solution);
 
-bool isBoundInfeasible(const HighsLogOptions& log_options, const HighsLp& lp);
+HighsStatus calculateColDualsQuad(const HighsLp& lp, HighsSolution& solution);
 
 bool isColDataNull(const HighsLogOptions& log_options,
                    const double* usr_col_cost, const double* usr_col_lower,

casadi/include/highs/lp_data/HighsModelUtils.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/lp_data/HighsOptions.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                     */
@@ -257,6 +257,7 @@ void reportOption(FILE* file, const OptionRecordString& option,
 
 const string kSimplexString = "simplex";
 const string kIpmString = "ipm";
+const string kPdlpString = "pdlp";
 
 const HighsInt kKeepNRowsDeleteRows = -1;
 const HighsInt kKeepNRowsDeleteEntries = 0;
@@ -303,6 +304,8 @@ struct HighsOptionsStruct {
   double objective_bound;
   double objective_target;
   HighsInt threads;
+  HighsInt user_bound_scale;
+  HighsInt user_cost_scale;
   HighsInt highs_debug_level;
   HighsInt highs_analysis_level;
   HighsInt simplex_strategy;
@@ -328,8 +331,20 @@ struct HighsOptionsStruct {
   // Options for IPM solver
   HighsInt ipm_iteration_limit;
 
+  // Options for PDLP solver
+  bool pdlp_native_termination;
+  bool pdlp_scaling;
+  HighsInt pdlp_iteration_limit;
+  HighsInt pdlp_e_restart_method;
+  double pdlp_d_gap_tol;
+
+  // Options for QP solver
+  HighsInt qp_iteration_limit;
+  HighsInt qp_nullspace_limit;
+
   // Advanced options
   HighsInt log_dev_level;
+  bool log_githash;
   bool solve_relaxation;
   bool allow_unbounded_or_infeasible;
   bool use_implied_bounds_from_presolve;
@@ -347,6 +362,7 @@ struct HighsOptionsStruct {
   HighsInt simplex_price_strategy;
   HighsInt simplex_unscaled_solution_strategy;
   HighsInt presolve_reduction_limit;
+  HighsInt restart_presolve_reduction_limit;
   HighsInt presolve_substitution_maxfillin;
   HighsInt presolve_rule_off;
   bool presolve_rule_logging;
@@ -366,6 +382,9 @@ struct HighsOptionsStruct {
   bool less_infeasible_DSE_check;
   bool less_infeasible_DSE_choose_row;
   bool use_original_HFactor_logic;
+  bool run_centring;
+  HighsInt max_centring_steps;
+  double centring_ratio_tolerance;
 
   // Options for iCrash
   bool icrash;
@@ -379,6 +398,7 @@ struct HighsOptionsStruct {
 
   // Options for MIP solver
   bool mip_detect_symmetry;
+  bool mip_allow_restart;
   HighsInt mip_max_nodes;
   HighsInt mip_max_stall_nodes;
   HighsInt mip_max_leaves;
@@ -404,6 +424,128 @@ struct HighsOptionsStruct {
   // Logging callback identifiers
   HighsLogOptions log_options;
   virtual ~HighsOptionsStruct() {}
+
+  HighsOptionsStruct()
+      : presolve(""),
+        solver(""),
+        parallel(""),
+        run_crossover(""),
+        time_limit(0.0),
+        solution_file(""),
+        write_model_file(""),
+        random_seed(0),
+        ranging(""),
+        infinite_cost(0.0),
+        infinite_bound(0.0),
+        small_matrix_value(0.0),
+        large_matrix_value(0.0),
+        primal_feasibility_tolerance(0.0),
+        dual_feasibility_tolerance(0.0),
+        ipm_optimality_tolerance(0.0),
+        objective_bound(0.0),
+        objective_target(0.0),
+        threads(0),
+        user_bound_scale(0),
+        user_cost_scale(0),
+        highs_debug_level(0),
+        highs_analysis_level(0),
+        simplex_strategy(0),
+        simplex_scale_strategy(0),
+        simplex_crash_strategy(0),
+        simplex_dual_edge_weight_strategy(0),
+        simplex_primal_edge_weight_strategy(0),
+        simplex_iteration_limit(0),
+        simplex_update_limit(0),
+        simplex_min_concurrency(0),
+        simplex_max_concurrency(0),
+        log_file(""),
+        write_model_to_file(false),
+        write_solution_to_file(false),
+        write_solution_style(0),
+        glpsol_cost_row_location(0),
+        output_flag(false),
+        log_to_console(false),
+        ipm_iteration_limit(0),
+        pdlp_native_termination(false),
+        pdlp_scaling(false),
+        pdlp_iteration_limit(0),
+        pdlp_e_restart_method(0),
+        pdlp_d_gap_tol(0.0),
+        qp_iteration_limit(0),
+        qp_nullspace_limit(0),
+        log_dev_level(0),
+        log_githash(false),
+        solve_relaxation(false),
+        allow_unbounded_or_infeasible(false),
+        use_implied_bounds_from_presolve(false),
+        lp_presolve_requires_basis_postsolve(false),
+        mps_parser_type_free(false),
+        keep_n_rows(0),
+        cost_scale_factor(0),
+        allowed_matrix_scale_factor(0),
+        allowed_cost_scale_factor(0),
+        ipx_dualize_strategy(0),
+        simplex_dualize_strategy(0),
+        simplex_permute_strategy(0),
+        max_dual_simplex_cleanup_level(0),
+        max_dual_simplex_phase1_cleanup_level(0),
+        simplex_price_strategy(0),
+        simplex_unscaled_solution_strategy(0),
+        presolve_reduction_limit(0),
+        restart_presolve_reduction_limit(0),
+        presolve_substitution_maxfillin(0),
+        presolve_rule_off(0),
+        presolve_rule_logging(false),
+        simplex_initial_condition_check(false),
+        no_unnecessary_rebuild_refactor(false),
+        simplex_initial_condition_tolerance(0.0),
+        rebuild_refactor_solution_error_tolerance(0.0),
+        dual_steepest_edge_weight_error_tolerance(0.0),
+        dual_steepest_edge_weight_log_error_threshold(0.0),
+        dual_simplex_cost_perturbation_multiplier(0.0),
+        primal_simplex_bound_perturbation_multiplier(0.0),
+        dual_simplex_pivot_growth_tolerance(0.0),
+        presolve_pivot_threshold(0.0),
+        factor_pivot_threshold(0.0),
+        factor_pivot_tolerance(0.0),
+        start_crossover_tolerance(0.0),
+        less_infeasible_DSE_check(false),
+        less_infeasible_DSE_choose_row(false),
+        use_original_HFactor_logic(false),
+        run_centring(false),
+        max_centring_steps(0),
+        centring_ratio_tolerance(0.0),
+        icrash(false),
+        icrash_dualize(false),
+        icrash_strategy(""),
+        icrash_starting_weight(0.0),
+        icrash_iterations(0),
+        icrash_approx_iter(0),
+        icrash_exact(false),
+        icrash_breakpoints(false),
+        mip_detect_symmetry(false),
+        mip_allow_restart(false),
+        mip_max_nodes(0),
+        mip_max_stall_nodes(0),
+        mip_max_leaves(0),
+        mip_max_improving_sols(0),
+        mip_lp_age_limit(0),
+        mip_pool_age_limit(0),
+        mip_pool_soft_limit(0),
+        mip_pscost_minreliable(0),
+        mip_min_cliquetable_entries_for_parallelism(0),
+        mip_report_level(0),
+        mip_feasibility_tolerance(0.0),
+        mip_rel_gap(0.0),
+        mip_abs_gap(0.0),
+        mip_heuristic_effort(0.0),
+        mip_min_logging_interval(0.0),
+#ifdef HIGHS_DEBUGSOL
+        mip_debug_solution_file(""),
+#endif
+        mip_improving_solution_save(false),
+        mip_improving_solution_report_sparse(false),
+        mip_improving_solution_file(""){};
 };
 
 // For now, but later change so HiGHS properties are string based so that new
@@ -471,8 +613,9 @@ class HighsOptions : public HighsOptionsStruct {
 
     record_string = new OptionRecordString(
         kSolverString,
-        "Solver option: \"simplex\", \"choose\" or \"ipm\". If "
-        "\"simplex\"/\"ipm\" is chosen then, for a MIP (QP) the integrality "
+        "Solver option: \"simplex\", \"choose\", \"ipm\" or \"pdlp\". If "
+        "\"simplex\"/\"ipm\"/\"pdlp\" is chosen then, for a MIP (QP) the "
+        "integrality "
         "constraint (quadratic term) will be ignored",
         advanced, &solver, kHighsChooseString);
     records.push_back(record_string);
@@ -545,13 +688,14 @@ class HighsOptions : public HighsOptionsStruct {
     records.push_back(record_double);
 
     record_double = new OptionRecordDouble(
-        "objective_bound", "Objective bound for termination of dual simplex",
-        advanced, &objective_bound, -kHighsInf, kHighsInf, kHighsInf);
+        "objective_bound",
+        "Objective bound for termination of the dual simplex solver", advanced,
+        &objective_bound, -kHighsInf, kHighsInf, kHighsInf);
     records.push_back(record_double);
 
     record_double = new OptionRecordDouble(
-        "objective_target", "Objective target for termination of MIP solver",
-        advanced,
+        "objective_target",
+        "Objective target for termination of the MIP solver", advanced,
         //"primal simplex and "
         &objective_target, -kHighsInf, -kHighsInf, kHighsInf);
     records.push_back(record_double);
@@ -566,6 +710,16 @@ class HighsOptions : public HighsOptionsStruct {
         &threads, 0, 0, kHighsIInf);
     records.push_back(record_int);
 
+    record_int = new OptionRecordInt(
+        "user_bound_scale", "Exponent of power-of-two bound scaling for model",
+        advanced, &user_bound_scale, -kHighsIInf, 0, kHighsIInf);
+    records.push_back(record_int);
+
+    record_int = new OptionRecordInt(
+        "user_cost_scale", "Exponent of power-of-two cost scaling for model",
+        advanced, &user_cost_scale, -kHighsIInf, 0, kHighsIInf);
+    records.push_back(record_int);
+
     record_int = new OptionRecordInt("highs_debug_level",
                                      "Debugging level in HiGHS", now_advanced,
                                      &highs_debug_level, kHighsDebugLevelMin,
@@ -747,6 +901,11 @@ class HighsOptions : public HighsOptionsStruct {
         advanced, &mip_detect_symmetry, true);
     records.push_back(record_bool);
 
+    record_bool = new OptionRecordBool("mip_allow_restart",
+                                       "Whether MIP restart is permitted",
+                                       advanced, &mip_allow_restart, true);
+    records.push_back(record_bool);
+
     record_int = new OptionRecordInt("mip_max_nodes",
                                      "MIP solver max number of nodes", advanced,
                                      &mip_max_nodes, 0, kHighsIInf, kHighsIInf);
@@ -780,7 +939,7 @@ class HighsOptions : public HighsOptionsStruct {
     record_string = new OptionRecordString(
         "mip_improving_solution_file",
         "File for reporting improving MIP solutions: not reported for an empty "
-        "string \"\"",
+        "string \\\"\\\"",
         advanced, &mip_improving_solution_file, kHighsFilenameDefault);
     records.push_back(record_string);
 
@@ -872,8 +1031,46 @@ class HighsOptions : public HighsOptionsStruct {
         &ipm_iteration_limit, 0, kHighsIInf, kHighsIInf);
     records.push_back(record_int);
 
+    record_bool = new OptionRecordBool(
+        "pdlp_native_termination",
+        "Use native termination for PDLP solver: Default = false", advanced,
+        &pdlp_native_termination, false);
+    records.push_back(record_bool);
+
+    record_bool = new OptionRecordBool(
+        "pdlp_scaling", "Scaling option for PDLP solver: Default = true",
+        advanced, &pdlp_scaling, true);
+    records.push_back(record_bool);
+
+    record_int = new OptionRecordInt(
+        "pdlp_iteration_limit", "Iteration limit for PDLP solver", advanced,
+        &pdlp_iteration_limit, 0, kHighsIInf, kHighsIInf);
+    records.push_back(record_int);
+
+    record_int = new OptionRecordInt("pdlp_e_restart_method",
+                                     "Restart mode for PDLP solver: 0 => none; "
+                                     "1 => GPU (default); 2 => CPU ",
+                                     advanced, &pdlp_e_restart_method, 0, 1, 2);
+    records.push_back(record_int);
+
+    record_double = new OptionRecordDouble(
+        "pdlp_d_gap_tol",
+        "Duality gap tolerance for PDLP solver: Default = 1e-4", advanced,
+        &pdlp_d_gap_tol, 1e-12, 1e-4, kHighsInf);
+    records.push_back(record_double);
+
+    record_int = new OptionRecordInt(
+        "qp_iteration_limit", "Iteration limit for QP solver", advanced,
+        &qp_iteration_limit, 0, kHighsIInf, kHighsIInf);
+    records.push_back(record_int);
+
+    record_int = new OptionRecordInt("qp_nullspace_limit",
+                                     "Nullspace limit for QP solver", advanced,
+                                     &qp_nullspace_limit, 0, 4000, kHighsIInf);
+    records.push_back(record_int);
+
     // Fix the number of user settable options
-    num_user_settable_options_ = records.size();
+    num_user_settable_options_ = static_cast<HighsInt>(records.size());
 
     // Advanced options
     advanced = true;
@@ -885,6 +1082,10 @@ class HighsOptions : public HighsOptionsStruct {
         kHighsLogDevLevelMax);
     records.push_back(record_int);
 
+    record_bool = new OptionRecordBool("log_githash", "Log the githash",
+                                       advanced, &log_githash, true);
+    records.push_back(record_bool);
+
     record_bool = new OptionRecordBool(
         "solve_relaxation", "Solve the relaxation of discrete model components",
         advanced, &solve_relaxation, false);
@@ -1057,6 +1258,13 @@ class HighsOptions : public HighsOptionsStruct {
         &presolve_reduction_limit, -1, -1, kHighsIInf);
     records.push_back(record_int);
 
+    record_int = new OptionRecordInt(
+        "restart_presolve_reduction_limit",
+        "Limit on number of further presolve reductions on restart in MIP "
+        "solver -1 => no limit, otherwise, must be positive",
+        advanced, &restart_presolve_reduction_limit, -1, -1, kHighsIInf);
+    records.push_back(record_int);
+
     record_int = new OptionRecordInt(
         "presolve_rule_off", "Bit mask of presolve rules that are not allowed",
         advanced, &presolve_rule_off, 0, 0, kHighsIInf);
@@ -1108,6 +1316,25 @@ class HighsOptions : public HighsOptionsStruct {
                              &less_infeasible_DSE_choose_row, true);
     records.push_back(record_bool);
 
+    record_bool =
+        new OptionRecordBool("run_centring", "Perform centring steps or not",
+                             advanced, &run_centring, false);
+    records.push_back(record_bool);
+
+    record_int =
+        new OptionRecordInt("max_centring_steps",
+                            "Maximum number of steps to use (default = 5) "
+                            "when computing the analytic centre",
+                            advanced, &max_centring_steps, 0, 5, kHighsIInf);
+    records.push_back(record_int);
+
+    record_double = new OptionRecordDouble(
+        "centring_ratio_tolerance",
+        "Centring stops when the ratio max(x_j*s_j) / min(x_j*s_j) is below "
+        "this tolerance (default = 100)",
+        advanced, &centring_ratio_tolerance, 0, 100, kHighsInf);
+    records.push_back(record_double);
+
     // Set up the log_options aliases
     log_options.clear();
     log_options.log_stream =
@@ -1118,7 +1345,7 @@ class HighsOptions : public HighsOptionsStruct {
   }
 
   void deleteRecords() {
-    for (HighsUInt i = 0; i < records.size(); i++) delete records[i];
+    for (size_t i = 0; i < records.size(); i++) delete records[i];
   }
 
  public:

casadi/include/highs/lp_data/HighsRanging.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                     */