casadi 3.6.7__cp310-none-manylinux2014_x86_64.whl → 3.7.1__cp310-none-manylinux2014_x86_64.whl

casadi/include/highs/interfaces/highs_c_api.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -18,7 +15,7 @@
 // Highs_mipCall or Highs_qpCall, and these methods return the
 // appropriate solution information
 //
-// For sophisticated applications, where esoteric solutiuon
+// For sophisticated applications, where esoteric solution
 // information is needed, or if a sequence of modified models need to
 // be solved, use the Highs_create method to generate a pointer to an
 // instance of the C++ Highs class, and then use any of a large number
@@ -120,6 +117,8 @@ const char* const kHighsCallbackDataOutPdlpIterationCountName =
 const char* const kHighsCallbackDataOutObjectiveFunctionValueName =
     "objective_function_value";
 const char* const kHighsCallbackDataOutMipNodeCountName = "mip_node_count";
+const char* const kHighsCallbackDataOutMipTotalLpIterationsName =
+    "mip_total_lp_iterations";
 const char* const kHighsCallbackDataOutMipPrimalBoundName = "mip_primal_bound";
 const char* const kHighsCallbackDataOutMipDualBoundName = "mip_dual_bound";
 const char* const kHighsCallbackDataOutMipGapName = "mip_gap";
@@ -227,11 +226,14 @@ HighsInt Highs_mipCall(const HighsInt num_col, const HighsInt num_row,
  * @param q_format  The format of the Hessian matrix in the form of a
  *                  `kHighsHessianStatus` constant. If q_num_nz > 0, this must
  *                  be `kHighsHessianFormatTriangular`.
- * @param q_start   The Hessian matrix is provided in the same format as the
- *                  constraint matrix, using `q_start`, `q_index`, and `q_value`
- *                  in the place of `a_start`, `a_index`, and `a_value`.
+ * @param q_start   The Hessian matrix is provided to HiGHS as the lower
+ *                  triangular component in compressed sparse column form
+ *                  (or, equivalently, as the upper triangular component
+ *                  in compressed sparse row form). The sparse matrix consists
+ *                  of three arrays, `q_start`, `q_index`, and `q_value`.
+ *                  `q_start` is an array of length [num_col].
  * @param q_index   An array of length [q_num_nz] with indices of matrix
- *                  sentries.
+ *                  entries.
  * @param q_value   An array of length [q_num_nz] with values of matrix entries.
  *
  * @returns A `kHighsStatus` constant indicating whether the call succeeded.
@@ -496,10 +498,13 @@ HighsInt Highs_passMip(void* highs, const HighsInt num_col,
  * @param a_index     An array of length [num_nz] with indices of matrix
  *                    entries.
  * @param a_value     An array of length [num_nz] with values of matrix entries.
- * @param q_start     The Hessian matrix is provided in the same format as the
- *                    constraint matrix, using `q_start`, `q_index`, and
- *                    `q_value` in the place of `a_start`, `a_index`, and
- *                    `a_value`. If the model is linear, pass NULL.
+ * @param q_start     The Hessian matrix is provided to HiGHS as the lower
+ *                    triangular component in compressed sparse column form
+ *                    (or, equivalently, as the upper triangular component
+ *                    in compressed sparse row form). The sparse matrix consists
+ *                    of three arrays, `q_start`, `q_index`, and `q_value`.
+ *                    `q_start` is an array of length [num_col]. If the model
+ *                    is linear, pass NULL.
  * @param q_index     An array of length [q_num_nz] with indices of matrix
  *                    entries. If the model is linear, pass NULL.
  * @param q_value     An array of length [q_num_nz] with values of matrix
@@ -529,11 +534,16 @@ HighsInt Highs_passModel(void* highs, const HighsInt num_col,
  * @param num_nz    The number of non-zero elements in the Hessian matrix.
  * @param format    The format of the Hessian matrix as a `kHighsHessianFormat`
  *                  constant. This must be `kHighsHessianFormatTriangular`.
- * @param start     The Hessian matrix is provided to HiGHS as the upper
- *                  triangular component in compressed sparse column form. The
- *                  sparse matrix consists of three arrays, `start`, `index`,
- *                  and `value`. `start` is an array of length [num_col]
- *                  containing the starting index of each column in `index`.
+ * @param start     The Hessian matrix is provided to HiGHS as the lower
+ *                  triangular component in compressed sparse column form
+ *                  (or, equivalently, as the upper triangular component
+ *                  in compressed sparse row form), using `q_start`, `q_index`,
+ *                  and `q_value`.The Hessian matrix is provided to HiGHS as the
+ *                  lower triangular component in compressed sparse column form.
+ *                  The sparse matrix consists of three arrays, `start`,
+ *                  `index`, and `value`. `start` is an array of length
+ *                  [num_col] containing the starting index of each column in
+ *                  `index`.
  * @param index     An array of length [num_nz] with indices of matrix entries.
  * @param value     An array of length [num_nz] with values of matrix entries.
  *
@@ -544,6 +554,72 @@ HighsInt Highs_passHessian(void* highs, const HighsInt dim,
                            const HighsInt* start, const HighsInt* index,
                            const double* value);
 
+/**
+ * Passes multiple linear objective data to HiGHS, clearing any such
+ * data already in HiGHS
+ *
+ * @param highs         A pointer to the Highs instance.
+ * @param weight        A pointer to the weights of the linear objective, with
+ *                      its positive/negative sign determining whether it is
+ *                      minimized or maximized during lexicographic optimization
+ * @param offset        A pointer to the objective offsets
+ * @param coefficients  A pointer to the objective coefficients
+ * @param abs_tolerance A pointer to the absolute tolerances used when
+ *                      constructing objective constraints during lexicographic
+ *                      optimization
+ * @param rel_tolerance A pointer to the relative tolerances used when
+ *                      constructing objective constraints during lexicographic
+ *                      optimization
+ * @param priority      A pointer to the priorities of the objectives during
+ *                      lexicographic optimization
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+
+HighsInt Highs_passLinearObjectives(const void* highs,
+                                    const HighsInt num_linear_objective,
+                                    const double* weight, const double* offset,
+                                    const double* coefficients,
+                                    const double* abs_tolerance,
+                                    const double* rel_tolerance,
+                                    const HighsInt* priority);
+
+/**
+ * Adds linear objective data to HiGHS
+ *
+ * @param highs         A pointer to the Highs instance.
+ * @param weight        The weight of the linear objective, with its
+ *                      positive/negative sign determining whether it is
+ *                      minimized or maximized during lexicographic
+ *                      optimization
+ * @param offset        The objective offset
+ * @param coefficients  A pointer to the objective coefficients
+ * @param abs_tolerance The absolute tolerance used when constructing an
+ *                      objective constraint during lexicographic optimization
+ * @param rel_tolerance The relative tolerance used when constructing an
+ *                      objective constraint during lexicographic optimization
+ * @param priority      The priority of this objective during lexicographic
+ *                      optimization
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+
+HighsInt Highs_addLinearObjective(const void* highs, const double weight,
+                                  const double offset,
+                                  const double* coefficients,
+                                  const double abs_tolerance,
+                                  const double rel_tolerance,
+                                  const HighsInt priority);
+
+/**
+ * Clears any multiple linear objective data in HiGHS
+ *
+ * @param highs A pointer to the Highs instance.
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+
+HighsInt Highs_clearLinearObjectives(const void* highs);
 /**
  * Pass the name of a row.
  *
@@ -568,6 +644,16 @@ HighsInt Highs_passRowName(const void* highs, const HighsInt row,
 HighsInt Highs_passColName(const void* highs, const HighsInt col,
                            const char* name);
 
+/**
+ * Pass the name of the model.
+ *
+ * @param highs A pointer to the Highs instance.
+ * @param name  The name of the model.
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+HighsInt Highs_passModelName(const void* highs, const char* name);
+
 /**
  * Read the option values from file.
  *
@@ -892,11 +978,13 @@ HighsInt Highs_getBasis(const void* highs, HighsInt* col_status,
 HighsInt Highs_getModelStatus(const void* highs);
 
 /**
- * Get an unbounded dual ray that is a certificate of primal infeasibility.
+ * Indicates whether a dual ray that is a certificate of primal
+ * infeasibility currently exists, and (at the expense of solving an
+ * LP) gets it if it does not and dual_ray_value is not nullptr.
  *
  * @param highs             A pointer to the Highs instance.
- * @param has_dual_ray      A pointer to an int to store 1 if the dual ray
- *                          exists.
+ * @param has_dual_ray      A pointer to an int to store 1 if a dual ray
+ *                          currently exists.
  * @param dual_ray_value    An array of length [num_row] filled with the
  *                          unbounded ray.
  *
@@ -906,7 +994,28 @@ HighsInt Highs_getDualRay(const void* highs, HighsInt* has_dual_ray,
                           double* dual_ray_value);
 
 /**
- * Get an unbounded primal ray that is a certificate of dual infeasibility.
+ * Indicates whether a dual unboundedness direction (corresponding to a
+ * certificate of primal infeasibility) exists, and (at the expense of
+ * solving an LP) gets it if it does not and
+ * dual_unboundedness_direction is not nullptr
+ *
+ * @param highs                                   A pointer to the Highs
+ *                                                instance.
+ * @param has_dual_unboundedness_direction        A pointer to an int to store 1
+ *                                                if the dual unboundedness
+ *                                                direction exists.
+ * @param dual_unboundedness_direction_value      An array of length [num_col]
+ *                                                filled with the unboundedness
+ *                                                direction.
+ */
+HighsInt Highs_getDualUnboundednessDirection(
+    const void* highs, HighsInt* has_dual_unboundedness_direction,
+    double* dual_unboundedness_direction_value);
+
+/**
+ * Indicates whether a primal ray that is a certificate of primal
+ * unboundedness currently exists, and (at the expense of solving an
+ * LP) gets it if it does not and primal_ray_value is not nullptr.
  *
  * @param highs             A pointer to the Highs instance.
  * @param has_primal_ray    A pointer to an int to store 1 if the primal ray
@@ -1137,6 +1246,19 @@ HighsInt Highs_setSolution(void* highs, const double* col_value,
                            const double* row_value, const double* col_dual,
                            const double* row_dual);
 
+/**
+ * Set a partial primal solution by passing values for a set of variables
+ *
+ * @param highs       A pointer to the Highs instance.
+ * @param num_entries Number of variables in the set
+ * @param index       Indices of variables in the set
+ * @param value       Values of variables in the set
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+HighsInt Highs_setSparseSolution(void* highs, const HighsInt num_entries,
+                                 const HighsInt* index, const double* value);
+
 /**
  * Set the callback method to use for HiGHS
  *
@@ -1304,6 +1426,25 @@ HighsInt Highs_addRows(void* highs, const HighsInt num_new_row,
                        const HighsInt num_new_nz, const HighsInt* starts,
                        const HighsInt* index, const double* value);
 
+/**
+ * Ensure that the constraint matrix of the incumbent model is stored
+ * column-wise.
+ *
+ * @param highs         A pointer to the Highs instance.
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+HighsInt Highs_ensureColwise(void* highs);
+
+/**
+ * Ensure that the constraint matrix of the incumbent model is stored row-wise.
+ *
+ * @param highs         A pointer to the Highs instance.
+ *
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+HighsInt Highs_ensureRowwise(void* highs);
+
 /**
  * Change the objective sense of the model.
  *
@@ -1691,7 +1832,7 @@ HighsInt Highs_getColsByMask(const void* highs, const HighsInt* mask,
  * @param from_row      The first row for which to query data for.
  * @param to_row        The last row (inclusive) for which to query data for.
  * @param num_row       An integer to be populated with the number of rows got
- *                      from the smodel.
+ *                      from the model.
  * @param lower         An array of size [to_row - from_row + 1] for the row
  *                      lower bounds.
  * @param upper         An array of size [to_row - from_row + 1] for the row
@@ -2149,6 +2290,38 @@ HighsInt Highs_getRanging(
     double* row_bound_dn_value, double* row_bound_dn_objective,
     HighsInt* row_bound_dn_in_var, HighsInt* row_bound_dn_ou_var);
 
+/**
+ * Compute the solution corresponding to a (possibly weighted) sum of
+ * (allowable) infeasibilities in an LP/MIP.
+ *
+ * If local penalties are not defined, pass NULL, and the global
+ * penalty will be used. Negative penalty values imply that the bound
+ * or RHS value cannot be violated
+ *
+ * @param highs                             A pointer to the Highs instance.
+ * @param const double global_lower_penalty The penalty for violating lower
+ * bounds on variables
+ * @param const double global_upper_penalty The penalty for violating upper
+ * bounds on variables
+ * @param const double global_rhs_penalty   The penalty for violating constraint
+ * RHS values
+ * @param const double* local_lower_penalty The penalties for violating specific
+ * lower bounds on variables
+ * @param const double* local_upper_penalty The penalties for violating specific
+ * upper bounds on variables
+ * @param const double* local_rhs_penalty   The penalties for violating specific
+ * constraint RHS values
+ * @returns A `kHighsStatus` constant indicating whether the call succeeded.
+ */
+
+HighsInt Highs_feasibilityRelaxation(void* highs,
+                                     const double global_lower_penalty,
+                                     const double global_upper_penalty,
+                                     const double global_rhs_penalty,
+                                     const double* local_lower_penalty,
+                                     const double* local_upper_penalty,
+                                     const double* local_rhs_penalty);
+
 /**
  * Releases all resources held by the global scheduler instance.
  *

casadi/include/highs/io/Filereader.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -20,9 +17,10 @@
 
 enum class FilereaderRetcode {
   kOk = 0,
-  kFileNotFound = 1,
-  kParserError = 2,
-  kNotImplemented = 3,
+  kWarning = 1,
+  kFileNotFound = 2,
+  kParserError = 3,
+  kNotImplemented = 4,
   kTimeout
 };
 

casadi/include/highs/io/FilereaderEms.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/io/FilereaderLp.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/io/FilereaderMps.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/io/HMPSIO.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -54,7 +51,7 @@ FilereaderRetcode readMps(
     vector<HighsVarType>& integerColumn, std::string& objective_name,
     vector<std::string>& col_names, vector<std::string>& row_names,
     HighsInt& Qdim, vector<HighsInt>& Qstart, vector<HighsInt>& Qindex,
-    vector<double>& Qvalue, HighsInt& cost_row_location,
+    vector<double>& Qvalue, HighsInt& cost_row_location, bool& warning_issued,
     const HighsInt keep_n_rows = 0);
 
 HighsStatus writeMps(

casadi/include/highs/io/HMpsFF.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -38,6 +35,8 @@
 
 using Triplet = std::tuple<HighsInt, HighsInt, double>;
 
+const std::string mps_comment_chars = "*$";
+
 enum class FreeFormatParserReturnCode {
   kSuccess,
   kParserError,
@@ -61,7 +60,8 @@ class HMpsFF {
                                          const std::string filename,
                                          HighsModel& model);
 
-  double time_limit = kHighsInf;
+  double time_limit_ = kHighsInf;
+  bool warning_issued_ = false;
 
  private:
   double start_time;
@@ -124,7 +124,6 @@ class HMpsFF {
   HighsInt fillMatrix(const HighsLogOptions& log_options);
   HighsInt fillHessian(const HighsLogOptions& log_options);
 
-  const bool kAnyFirstNonBlankAsStarImpliesComment = false;
   /// how to treat variables that appear in COLUMNS section first
   /// assume them to be binary as in the original IBM interpretation
   /// or integer with default bounds
@@ -147,6 +146,7 @@ class HMpsFF {
     kCsection,
     kDelayedrows,
     kModelcuts,
+    kUsercuts,
     kIndicators,
     kSets,
     kSos,
@@ -189,6 +189,9 @@ class HMpsFF {
 
   mutable std::string section_args;
 
+  bool timeout();
+  bool getMpsLine(std::istream& file, std::string& strline, bool& skip);
+
   FreeFormatParserReturnCode parse(const HighsLogOptions& log_options,
                                    const std::string& filename);
   // Checks first word of strline and wraps it by it_begin and it_end

casadi/include/highs/io/HighsIO.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -18,13 +15,13 @@
 #include <iostream>
 
 #include "lp_data/HighsCallback.h"
-//#include "util/HighsInt.h"
+// #include "util/HighsInt.h"
 
 class HighsOptions;
 
 const HighsInt kIoBufferSize = 1024;  // 65536;
 
-enum class HighsFileType { kNone = 0, kOther, kMps, kLp, kMd, kHtml };
+enum class HighsFileType { kMinimal = 0, kFull, kMps, kLp, kMd };
 
 /**
  * @brief IO methods for HiGHS - currently just print/log messages
@@ -88,6 +85,14 @@ void highsLogUser(const HighsLogOptions& log_options_, const HighsLogType type,
 void highsLogDev(const HighsLogOptions& log_options_, const HighsLogType type,
                  const char* format, ...);
 
+/**
+ * @brief Replaces fprintf(file,... so that when file=stdout highsLogUser is
+ * used
+ */
+// Printing format: must contain exactly one "\n" at end of format
+void highsFprintfString(FILE* file, const HighsLogOptions& log_options_,
+                        const std::string& s);
+
 /**
  * @brief For development logging when true log_options may not be available -
  * indicated by null pointer

casadi/include/highs/io/LoadOptions.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/ipm/IpxSolution.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

casadi/include/highs/ipm/IpxWrapper.h

@@ -2,9 +2,6 @@
 /*                                                                       */
 /*    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                     */
 /*                                                                       */
 /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
@@ -31,10 +28,10 @@ HighsStatus solveLpIpx(const HighsOptions& options, HighsTimer& timer,
                        HighsCallback& callback);
 
 void fillInIpxData(const HighsLp& lp, ipx::Int& num_col, ipx::Int& num_row,
-                   std::vector<double>& obj, std::vector<double>& col_lb,
-                   std::vector<double>& col_ub, std::vector<ipx::Int>& Ap,
-                   std::vector<ipx::Int>& Ai, std::vector<double>& Ax,
-                   std::vector<double>& rhs,
+                   double& offset, std::vector<double>& obj,
+                   std::vector<double>& col_lb, std::vector<double>& col_ub,
+                   std::vector<ipx::Int>& Ap, std::vector<ipx::Int>& Ai,
+                   std::vector<double>& Ax, std::vector<double>& rhs,
                    std::vector<char>& constraint_type);
 
 HighsStatus reportIpxSolveStatus(const HighsOptions& options,

casadi/include/highs/ipm/ipx/control.h

@@ -91,6 +91,7 @@ public:
     double centringRatioReduction() const {return parameters_.centring_ratio_reduction; }
     double centringAlphaScaling() const{return parameters_.centring_alpha_scaling; }
     ipxint badProductsTolerance() const{return parameters_.bad_products_tolerance; }
+    bool timelessLog() const{return parameters_.timeless_log; }
 
     const Parameters& parameters() const;
     void parameters(const Parameters& new_parameters);

casadi/include/highs/ipm/ipx/ipx_parameters.h

@@ -64,6 +64,7 @@ struct ipx_parameters {
 
     /* HiGHS logging parameters */
     bool highs_logging;
+    bool timeless_log;
     const HighsLogOptions* log_options;
   
 };

casadi/include/highs/ipm/ipx/lp_solver.h

@@ -28,7 +28,8 @@ public:
     //  IPX_ERROR_invalid_dimension
     //  IPX_ERROR_invalid_matrix
     //  IPX_ERROR_invalid_vector
-    Int LoadModel(Int num_var, const double* obj, const double* lb,
+    Int LoadModel(Int num_var, const double offset,
+		  const double* obj, const double* lb,
                   const double* ub, Int num_constr, const Int* Ap,
                   const Int* Ai, const double* Ax, const double* rhs,
                   const char* constr_type);
@@ -94,7 +95,7 @@ public:
     Int GetBasicSolution(double* x, double* slack, double* y, double* z,
                          Int* cbasis, Int* vbasis) const;
 
-    // Returns/sets all paramters. Without calling SetParameters(), the solver
+    // Returns/sets all parameters. Without calling SetParameters(), the solver
     // uses the default values of a Parameters object.
     Parameters GetParameters() const;
     void SetParameters(Parameters new_parameters);

casadi/include/highs/ipm/ipx/model.h

@@ -58,8 +58,8 @@ public:
     //  IPX_ERROR_invalid_vector
     Int Load(const Control& control, Int num_constr, Int num_var,
              const Int* Ap, const Int* Ai, const double* Ax,
-             const double* rhs, const char* constr_type, const double* obj,
-             const double* lbuser, const double* ubuser);
+             const double* rhs, const char* constr_type, const double offset,
+	     const double* obj, const double* lbuser, const double* ubuser);
     // Performs Flippo's test for deciding dualization
     bool filippoDualizationTest() const;
     // Writes statistics of input data and preprocessing to @info.
@@ -93,6 +93,9 @@ public:
     const SparseMatrix& AI() const { return AI_; }
     const SparseMatrix& AIt() const { return AIt_; }
 
+    // Returns the offset
+    const double offset() const { return offset_; }
+  
     // Returns a reference to a model vector.
     const Vector& b() const { return b_; }
     const Vector& c() const { return c_; }
@@ -207,7 +210,7 @@ private:
     //  IPX_ERROR_invalid_vector
     Int CopyInput(Int num_constr, Int num_var, const Int* Ap, const Int* Ai,
                   const double* Ax, const double* rhs, const char* constr_type,
-                  const double* obj, const double* lbuser,
+                  const double offset, const double* obj, const double* lbuser,
                   const double* ubuser);
 
     // Scales A_, scaled_obj_, scaled_rhs_, scaled_lbuser_ and scaled_ubuser_
@@ -376,6 +379,7 @@ private:
     std::vector<char> constr_type_;
     double norm_obj_{0.0};        // Infnorm(obj) as given by user
     double norm_rhs_{0.0};        // Infnorm(rhs,lb,ub) as given by user
+    double offset_;
     Vector scaled_obj_;
     Vector scaled_rhs_;
     Vector scaled_lbuser_;