lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/build/include/highs/io/Filereader.h

@@ -0,0 +1,45 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file io/Filereader.h
+ * @brief
+ */
+#ifndef IO_FILEREADER_H_
+#define IO_FILEREADER_H_
+
+#include "io/HighsIO.h"
+#include "lp_data/HighsOptions.h"
+#include "model/HighsModel.h"
+
+enum class FilereaderRetcode {
+  kOk = 0,
+  kWarning = 1,
+  kFileNotFound = 2,
+  kParserError = 3,
+  kNotImplemented = 4,
+  kTimeout
+};
+
+void interpretFilereaderRetcode(const HighsLogOptions& log_options,
+                                const std::string& filename,
+                                const FilereaderRetcode code);
+std::string extractModelName(const std::string& filename);
+
+class Filereader {
+ public:
+  virtual FilereaderRetcode readModelFromFile(const HighsOptions& options,
+                                              const std::string filename,
+                                              HighsModel& model) = 0;
+  virtual HighsStatus writeModelToFile(const HighsOptions& options,
+                                       const std::string filename,
+                                       const HighsModel& model) = 0;
+  static Filereader* getFilereader(const HighsLogOptions& log_options,
+                                   const std::string filename);
+
+  virtual ~Filereader(){};
+};
+#endif

data/ext/lpsolver-highs/build/include/highs/io/FilereaderLp.h

@@ -0,0 +1,49 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file io/FilereaderLp.cpp
+ * @brief
+ */
+
+#ifndef IO_FILEREADER_LP_H_
+#define IO_FILEREADER_LP_H_
+
+#include <list>
+
+#include "io/Filereader.h"
+#include "io/HighsIO.h"
+
+#define BUFFERSIZE 561
+#define LP_MAX_LINE_LENGTH 560
+#define LP_MAX_NAME_LENGTH 255
+
+#define LP_COMMENT_FILESTART ("File written by HiGHS .lp file handler")
+
+class FilereaderLp : public Filereader {
+ public:
+  FilereaderRetcode readModelFromFile(const HighsOptions& options,
+                                      const std::string filename,
+                                      HighsModel& model);
+
+  HighsStatus writeModelToFile(const HighsOptions& options,
+                               const std::string filename,
+                               const HighsModel& model);
+
+ private:
+  // functions to write files
+  HighsInt linelength;
+  void writeToFile(FILE* file, const char* format, ...);
+  void writeToFileLineEnd(FILE* file);
+  void writeToFileValue(FILE* file, const double value,
+                        const bool force_plus = true);
+  void writeToFileVar(FILE* file, const std::string var_name);
+  void writeToFileMatrixRow(FILE* file, const HighsInt iRow,
+                            const HighsSparseMatrix& ar_matrix,
+                            const std::vector<string>& col_names);
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/io/FilereaderMps.h

@@ -0,0 +1,27 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file io/FilereaderMps.h
+ * @brief
+ */
+#ifndef IO_FILEREADER_MPS_H_
+#define IO_FILEREADER_MPS_H_
+
+#include "io/Filereader.h"
+#include "lp_data/HighsStatus.h"
+
+class FilereaderMps : public Filereader {
+ public:
+  FilereaderRetcode readModelFromFile(const HighsOptions& options,
+                                      const std::string filename,
+                                      HighsModel& model);
+  HighsStatus writeModelToFile(const HighsOptions& options,
+                               const std::string filename,
+                               const HighsModel& model);
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/io/HMPSIO.h

@@ -0,0 +1,78 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file io/HMPSIO.h
+ * @brief
+ */
+#ifndef IO_HMPSIO_H_
+#define IO_HMPSIO_H_
+
+#include <cmath>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <map>
+#include <vector>
+
+#include "io/Filereader.h"
+#include "util/HighsInt.h"
+
+using std::string;
+using std::vector;
+
+const HighsInt MPS_ROW_TY_N = 0;
+const HighsInt MPS_ROW_TY_E = 1;
+const HighsInt MPS_ROW_TY_L = 2;
+const HighsInt MPS_ROW_TY_G = 3;
+const HighsInt field_1_start = 1;
+const HighsInt field_1_width = 2;
+const HighsInt field_2_start = 4;
+const HighsInt field_2_width = 8;
+const HighsInt field_3_start = 14;
+const HighsInt field_3_width = 8;
+const HighsInt field_4_start = 24;
+const HighsInt field_4_width = 12;
+const HighsInt field_5_start = 39;
+const HighsInt field_5_width = 8;
+const HighsInt field_6_start = 49;
+const HighsInt field_6_width = 12;
+
+FilereaderRetcode readMps(
+    const HighsLogOptions& log_options, const std::string& filename,
+    HighsInt mxNumRow, HighsInt mxNumCol, HighsInt& numRow, HighsInt& numCol,
+    ObjSense& objSense, double& objOffset, vector<HighsInt>& Astart,
+    vector<HighsInt>& Aindex, vector<double>& Avalue, vector<double>& colCost,
+    vector<double>& colLower, vector<double>& colUpper,
+    vector<double>& rowLower, vector<double>& rowUpper,
+    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, bool& warning_issued,
+    const HighsInt keep_n_rows = 0);
+
+HighsStatus writeMps(
+    const HighsLogOptions& log_options, const std::string& filename,
+    const std::string& model_name, const HighsInt& num_row,
+    const HighsInt& num_col, const HighsInt& q_dim, const ObjSense& sense,
+    const double& offset, const vector<double>& col_cost,
+    const vector<double>& col_lower, const vector<double>& col_upper,
+    const vector<double>& row_lower, const vector<double>& row_upper,
+    const vector<HighsInt>& a_start, const vector<HighsInt>& a_index,
+    const vector<double>& a_value, const vector<HighsInt>& q_start,
+    const vector<HighsInt>& q_index, const vector<double>& q_value,
+    const vector<HighsVarType>& integrality, const std::string& objective_name,
+    const vector<std::string>& col_names, const vector<std::string>& row_names,
+    const bool use_free_format = true);
+
+bool load_mpsLine(std::istream& file, HighsVarType& integerVar, HighsInt lmax,
+                  char* line, char* flag, double* data);
+
+HighsStatus writeModelAsMps(const HighsOptions& options,
+                            const std::string& filename,
+                            const HighsModel& model, const bool free = true);
+
+#endif /* IO_HMPSIO_H_ */

data/ext/lpsolver-highs/build/include/highs/io/HMpsFF.h

@@ -0,0 +1,245 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file io/HMpsFF.h
+ * @brief
+ */
+#ifndef IO_HMPSFF_H_
+#define IO_HMPSFF_H_
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <cmath>
+#include <cstdio>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <memory>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "io/HighsIO.h"
+#include "model/HighsModel.h"
+// #include "util/HighsInt.h"
+#include "util/stringutil.h"
+
+using Triplet = std::tuple<HighsInt, HighsInt, double>;
+
+const std::string mps_comment_chars = "*$";
+
+enum class FreeFormatParserReturnCode {
+  kSuccess,
+  kParserError,
+  kFileNotFound,
+  kFixedFormat,
+  kTimeout,
+};
+
+namespace free_format_parser {
+
+// private:
+using wall_clock = std::chrono::high_resolution_clock;
+using time_point = wall_clock::time_point;
+
+double getWallTime();
+
+class HMpsFF {
+ public:
+  HMpsFF() {}
+  FreeFormatParserReturnCode loadProblem(const HighsLogOptions& log_options,
+                                         const std::string filename,
+                                         HighsModel& model);
+
+  double time_limit_ = kHighsInf;
+  bool warning_issued_ = false;
+
+ private:
+  double start_time;
+
+  HighsInt num_row;
+  HighsInt num_col;
+  HighsInt num_nz;
+  std::string mps_name;
+
+  ObjSense obj_sense = ObjSense::kMinimize;  // Minimization by default
+  double obj_offset = 0;
+
+  std::vector<HighsInt> a_start;
+  std::vector<HighsInt> a_index;
+  std::vector<double> a_value;
+  std::vector<double> col_cost;
+  std::vector<double> col_lower;
+  std::vector<double> col_upper;
+  std::vector<double> row_lower;
+  std::vector<double> row_upper;
+
+  std::vector<std::string> row_names;
+  std::vector<std::string> col_names;
+
+  std::vector<HighsVarType> col_integrality;
+
+  HighsInt q_dim;
+  std::vector<HighsInt> q_start;
+  std::vector<HighsInt> q_index;
+  std::vector<double> q_value;
+
+  // Keep track of columns that are binary by default, being columns
+  // that are defined as integer by markers in the column section, or
+  // as binary by having a BV flag in the BOUNDS section, and without
+  // any LI or UI flags in the BOUNDS section
+  std::vector<bool> col_binary;
+
+  // Record where the cost row is encountered
+  HighsInt cost_row_location;
+
+  // Record whether there are duplicate row or column names, and the
+  // name and indices of the first duplicates
+  bool has_duplicate_row_name_;
+  bool has_duplicate_col_name_;
+  std::string duplicate_row_name_;
+  HighsInt duplicate_row_name_index0_;
+  HighsInt duplicate_row_name_index1_;
+  std::string duplicate_col_name_;
+  HighsInt duplicate_col_name_index0_;
+  HighsInt duplicate_col_name_index1_;
+
+  // Record whether there is a data entry in the RHS section of an MPS
+  // file for the objective or a row. Have to be class data members so
+  // that they can be used by parseName and addRhs in HMpsFF::parseRhs
+  bool has_obj_entry_;
+  std::vector<bool> has_row_entry_;
+
+  /// load LP from MPS file as transposed triplet matrix
+  HighsInt parseFile(std::string filename);
+  HighsInt fillMatrix(const HighsLogOptions& log_options);
+  HighsInt fillHessian(const HighsLogOptions& log_options);
+
+  /// 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
+  bool kintegerVarsInColumnsAreBinary = true;
+
+  enum class Parsekey {
+    kName,
+    kObjsense,
+    kMax,
+    kMin,
+    kRows,
+    kCols,
+    kRhs,
+    kBounds,
+    kRanges,
+    kQsection,
+    kQmatrix,
+    kQuadobj,
+    kQcmatrix,
+    kCsection,
+    kDelayedrows,
+    kModelcuts,
+    kUsercuts,
+    kIndicators,
+    kSets,
+    kSos,
+    kGencons,
+    kPwlobj,
+    kPwlnam,
+    kPwlcon,
+    kNone,
+    kEnd,
+    kFail,
+    kComment,
+    kFixedFormat,
+    kTimeout
+  };
+
+  enum class Boundtype { kLe, kEq, kGe };  //, kFr };
+
+  // see
+  // https://docs.mosek.com/latest_kkt/capi/mps-format.html#csection-optional
+  enum class ConeType { kZero, kQuad, kRQuad, kPExp, kPPow, kDExp, kDPow };
+
+  std::string objective_name;
+  std::vector<Boundtype> row_type;
+  std::vector<HighsInt> integer_column;
+
+  std::vector<Triplet> entries;
+  HessianFormat q_format;
+  std::vector<Triplet> q_entries;
+  std::vector<std::vector<Triplet>> qrows_entries;
+  std::vector<std::pair<HighsInt, double>> coeffobj;
+
+  std::vector<std::string> sos_name;
+  std::vector<short> sos_type;
+  std::vector<std::vector<std::pair<HighsInt, double>>> sos_entries;
+
+  std::vector<std::string> cone_name;
+  std::vector<ConeType> cone_type;
+  std::vector<double> cone_param;
+  std::vector<std::vector<HighsInt>> cone_entries;
+  std::unordered_map<std::string, HighsInt> rowname2idx;
+  std::unordered_map<std::string, HighsInt> colname2idx;
+
+  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
+  HMpsFF::Parsekey checkFirstWord(std::string& strline, size_t& start,
+                                  size_t& end, std::string& word) const;
+
+  // Get index of column from column name, possibly adding new column
+  // if no index is found
+  HighsInt getColIdx(const std::string& colname, const bool add_if_new = true);
+
+  HMpsFF::Parsekey parseDefault(const HighsLogOptions& log_options,
+                                std::istream& file);
+  HMpsFF::Parsekey parseObjsense(const HighsLogOptions& log_options,
+                                 std::istream& file);
+  HMpsFF::Parsekey parseRows(const HighsLogOptions& log_options,
+                             std::istream& file);
+  HMpsFF::Parsekey parseCols(const HighsLogOptions& log_options,
+                             std::istream& file);
+  HMpsFF::Parsekey parseRhs(const HighsLogOptions& log_options,
+                            std::istream& file);
+  HMpsFF::Parsekey parseRanges(const HighsLogOptions& log_options,
+                               std::istream& file);
+  HMpsFF::Parsekey parseBounds(const HighsLogOptions& log_options,
+                               std::istream& file);
+  HMpsFF::Parsekey parseHessian(const HighsLogOptions& log_options,
+                                std::istream& file,
+                                const HMpsFF::Parsekey keyword);
+  HMpsFF::Parsekey parseQuadRows(const HighsLogOptions& log_options,
+                                 std::istream& file,
+                                 const HMpsFF::Parsekey keyword);
+  HMpsFF::Parsekey parseQuadMatrix(const HighsLogOptions& log_options,
+                                   std::istream& file,
+                                   const std::string& section_name,
+                                   std::vector<Triplet>& q_entries);
+
+  HMpsFF::Parsekey parseCones(const HighsLogOptions& log_options,
+                              std::istream& file);
+  HMpsFF::Parsekey parseSos(const HighsLogOptions& log_options,
+                            std::istream& file, const HMpsFF::Parsekey keyword);
+
+  bool cannotParseSection(const HighsLogOptions& log_options,
+                          const HMpsFF::Parsekey keyword);
+  bool allZeroed(const std::vector<double>& value);
+  double getValue(const std::string& word, bool& is_nan,
+                  const HighsInt id = -1) const;
+};
+
+}  // namespace free_format_parser
+#endif /* IO_HMPSFF_H_ */

data/ext/lpsolver-highs/build/include/highs/io/HighsIO.h

@@ -0,0 +1,118 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file io/HighsIO.h
+ * @brief IO methods for HiGHS - currently just print/log messages
+ */
+#ifndef HIGHS_IO_H
+#define HIGHS_IO_H
+
+#include <array>
+#include <iostream>
+
+#include "lp_data/HighsCallback.h"
+
+class HighsOptions;
+
+const HighsInt kIoBufferSize = 1024;  // 65536;
+
+enum class HighsFileType { kMinimal = 0, kFull, kMps, kLp, kMd };
+
+/**
+ * @brief IO methods for HiGHS - currently just print/log messages
+ */
+const char* const HighsLogTypeTag[] = {"", "",          "",
+                                       "", "WARNING: ", "ERROR:   "};
+enum LogDevLevel {
+  kHighsLogDevLevelMin = 0,
+  kHighsLogDevLevelNone = kHighsLogDevLevelMin,  // 0
+  kHighsLogDevLevelInfo,                         // 1
+  kHighsLogDevLevelDetailed,                     // 2
+  kHighsLogDevLevelVerbose,                      // 3
+  kHighsLogDevLevelMax = kHighsLogDevLevelVerbose
+};
+
+struct HighsLogOptions {
+  FILE* log_stream;
+  bool* output_flag;
+  bool* log_to_console;
+  HighsInt* log_dev_level;
+  void (*user_log_callback)(HighsLogType, const char*, void*);
+  void* user_log_callback_data;
+  HighsCallbackFunctionType user_callback;
+  void* user_callback_data;
+  bool user_callback_active;
+  void clear();
+  HighsLogOptions()
+      : log_stream(nullptr),
+        output_flag(nullptr),
+        log_to_console(nullptr),
+        log_dev_level(nullptr),
+        user_log_callback(nullptr),
+        user_log_callback_data(nullptr),
+        user_callback_data(nullptr),
+        user_callback_active(false){};
+};
+
+/**
+ * @brief Write the HiGHS version and copyright statement
+ */
+void highsLogHeader(const HighsLogOptions& log_options, const bool log_githash);
+
+/**
+ * @brief Convert a double number to a string using given tolerance
+ */
+std::array<char, 32> highsDoubleToString(const double val,
+                                         const double tolerance);
+
+/**
+ * @brief For _single-line_ user logging with message type notification
+ */
+// Printing format: must contain exactly one "\n" at end of format
+void highsLogUser(const HighsLogOptions& log_options_, const HighsLogType type,
+                  const char* format, ...);
+
+/**
+ * @brief For development logging
+ */
+void highsLogDev(const HighsLogOptions& log_options_, const HighsLogType type,
+                 const char* format, ...);
+
+/**
+ * @brief Gets filename extension
+ */
+std::string getFilenameExt(const std::string& filename);
+
+/**
+ * @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
+ */
+void highsReportDevInfo(const HighsLogOptions* log_options,
+                        const std::string& line);
+
+void highsOpenLogFile(HighsOptions& options, const std::string& log_file);
+
+void highsReportLogOptions(const HighsLogOptions& log_options_);
+
+std::string highsFormatToString(const char* format, ...);
+
+const std::string highsBoolToString(const bool b,
+                                    const HighsInt field_width = 2);
+
+const std::string highsInsertMdEscapes(const std::string& from_string);
+const std::string highsInsertMdId(const std::string& from_string);
+const std::string highsTimeToString(const double time);
+const std::string highsTimeSecondToString(const double time);
+#endif

data/ext/lpsolver-highs/build/include/highs/io/LoadOptions.h

@@ -0,0 +1,24 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file io/LoadOptions.h
+ * @brief
+ */
+
+#ifndef IO_LOAD_OPTIONS_H_
+#define IO_LOAD_OPTIONS_H_
+
+#include "lp_data/HighsOptions.h"
+
+enum class HighsLoadOptionsStatus { kError = -1, kOk = 0, kEmpty = 1 };
+
+// For extended options to be parsed from filename
+HighsLoadOptionsStatus loadOptionsFromFile(
+    const HighsLogOptions& report_log_options, HighsOptions& options,
+    const std::string& filename);
+
+#endif

data/ext/lpsolver-highs/build/include/highs/io/filereaderlp/builder.hpp

@@ -0,0 +1,25 @@
+#ifndef __READERLP_BUILDER_HPP__
+#define __READERLP_BUILDER_HPP__
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "io/filereaderlp/model.hpp"
+
+struct Builder {
+  std::unordered_map<std::string, std::shared_ptr<Variable>> variables;
+
+  Model model;
+
+  std::shared_ptr<Variable> getvarbyname(const std::string& name) {
+    auto it = variables.find(name);
+    if (it != variables.end()) return it->second;
+    auto newvar = std::shared_ptr<Variable>(new Variable(name));
+    variables.insert(std::make_pair(name, newvar));
+    model.variables.push_back(newvar);
+    return newvar;
+  }
+};
+
+#endif

data/ext/lpsolver-highs/build/include/highs/io/filereaderlp/def.hpp

@@ -0,0 +1,19 @@
+#ifndef __READERLP_DEF_HPP__
+#define __READERLP_DEF_HPP__
+
+#include <stdexcept>
+#include <string>
+
+void inline lpassert(bool condition) {
+  if (!condition) {
+    throw std::invalid_argument("File not existent or illegal file format.");
+  }
+}
+
+const std::string LP_KEYWORD_INF[] = {"infinity", "inf"};
+const std::string LP_KEYWORD_FREE[] = {"free"};
+
+const unsigned int LP_KEYWORD_INF_N = 2;
+const unsigned int LP_KEYWORD_FREE_N = 1;
+
+#endif