lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/util/HighsUtils.h

@@ -0,0 +1,272 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file util/HUtils.h
+ * @brief Class-independent utilities for HiGHS
+ */
+#ifndef UTIL_HIGHSUTILS_H_
+#define UTIL_HIGHSUTILS_H_
+
+#include <cassert>
+#include <string>
+#include <vector>
+
+#include "lp_data/HighsOptions.h"
+
+const HighsInt kIndexCollectionCreateOk = 0;
+const HighsInt kIndexCollectionCreateIllegalInterval = 1;
+const HighsInt kIndexCollectionCreateIllegalSetSize = 1;
+const HighsInt kIndexCollectionCreateIllegalSetDimension = 2;
+const HighsInt kIndexCollectionCreateIllegalSetOrder = 3;
+const HighsInt kIndexCollectionCreateIllegalMaskSize = 1;
+
+void highsSparseTranspose(HighsInt numRow, HighsInt numCol,
+                          const std::vector<HighsInt>& Astart,
+                          const std::vector<HighsInt>& Aindex,
+                          const std::vector<double>& Avalue,
+                          std::vector<HighsInt>& ARstart,
+                          std::vector<HighsInt>& ARindex,
+                          std::vector<double>& ARvalue);
+
+struct HighsIndexCollection {
+  HighsInt dimension_ = -1;
+  bool is_interval_ = false;
+  HighsInt from_ = -1;
+  HighsInt to_ = -2;
+  bool is_set_ = false;
+  HighsInt set_num_entries_ = -1;
+  std::vector<HighsInt> set_;
+  bool is_mask_ = false;
+  std::vector<HighsInt> mask_;
+};
+
+struct HighsValueDistribution {
+  std::string distribution_name_;
+  std::string value_name_;
+  HighsInt num_count_;
+  HighsInt num_zero_;
+  HighsInt num_one_;
+  double min_value_;
+  double max_value_;
+  std::vector<double> limit_;
+  std::vector<HighsInt> count_;
+  HighsInt sum_count_;
+};
+
+struct HighsScatterData {
+  HighsInt max_num_point_;
+  HighsInt num_point_;
+  HighsInt last_point_;
+  std::vector<double> value0_;
+  std::vector<double> value1_;
+  bool have_regression_coeff_;
+  double linear_coeff0_;
+  double linear_coeff1_;
+  double linear_regression_error_;
+  double log_coeff0_;
+  double log_coeff1_;
+  double log_regression_error_;
+  HighsInt num_error_comparison_;
+  HighsInt num_awful_linear_;
+  HighsInt num_awful_log_;
+  HighsInt num_bad_linear_;
+  HighsInt num_bad_log_;
+  HighsInt num_fair_linear_;
+  HighsInt num_fair_log_;
+  HighsInt num_better_linear_;
+  HighsInt num_better_log_;
+};
+
+const double awful_regression_error = 2.0;
+const double bad_regression_error = 0.2;
+const double fair_regression_error = 0.02;
+
+HighsInt create(HighsIndexCollection& index_collection, const HighsInt from_col,
+                const HighsInt to_col, const HighsInt dimension);
+
+HighsInt create(HighsIndexCollection& index_collection,
+                const HighsInt num_set_entries, const HighsInt* set,
+                const HighsInt dimension);
+
+HighsInt create(HighsIndexCollection& index_collection, const HighsInt* mask,
+                const HighsInt dimension);
+
+bool ok(const HighsIndexCollection& index_collection);
+
+void limits(const HighsIndexCollection& index_collection, HighsInt& from_k,
+            HighsInt& to_k);
+
+void updateOutInIndex(const HighsIndexCollection& index_collection,
+                      HighsInt& out_from_ix, HighsInt& out_to_ix,
+                      HighsInt& in_from_ix, HighsInt& in_to_ix,
+                      HighsInt& current_set_entry);
+
+HighsInt dataSize(const HighsIndexCollection& index_collection);
+
+bool highsVarTypeUserDataNotNull(const HighsLogOptions& log_options,
+                                 const HighsVarType* user_data,
+                                 const std::string& name);
+bool intUserDataNotNull(const HighsLogOptions& log_options,
+                        const HighsInt* user_data, const std::string& name);
+bool doubleUserDataNotNull(const HighsLogOptions& log_options,
+                           const double* user_data, const std::string& name);
+
+double getNorm2(const std::vector<double>& values);
+
+/**
+ * @brief Logical check of double being +Infinity
+ */
+bool highs_isInfinity(double val  //!< Value being tested against +Infinity
+);
+/**
+ * @brief Returns the relative difference of two doubles
+ */
+double highsRelativeDifference(const double v0, const double v1);
+
+/**
+ * @brief Analyse the values of a vector, assessing how many are in
+ * each power of ten, and possibly analyse the distribution of
+ * different values
+ *
+ * NB If log_options is a null pointer then printf is used
+ */
+void analyseVectorValues(
+    const HighsLogOptions* log_options,
+    const std::string& message,      //!< Message to be printed
+    HighsInt vecDim,                 //!< Dimension of vector
+    const std::vector<double>& vec,  //!< Vector of values
+    bool analyseValueList = false,   //!< Possibly analyse the distribution of
+                                     //!< different values in the vector
+    const std::string& model_name =
+        "Unknown"  //!< Model name to report if analysing distribution of
+                   //!< different values in the vector
+);
+
+void analyseVectorValues(
+    const HighsLogOptions* log_options,
+    const std::string& message,        //!< Message to be printed
+    HighsInt vecDim,                   //!< Dimension of vector
+    const std::vector<HighsInt>& vec,  //!< Vector of values
+    const std::string& model_name =
+        "Unknown"  //!< Model name to report if analysing distribution of
+                   //!< different values in the vector
+);
+
+void analyseMatrixSparsity(
+    const HighsLogOptions& log_options,
+    const char* message,                  //!< Message to be printed
+    HighsInt numCol,                      //!< Number of columns
+    HighsInt numRow,                      //!< Number of rows
+    const std::vector<HighsInt>& Astart,  //!< Matrix column starts
+    const std::vector<HighsInt>& Aindex   //!< Matrix row indices
+);
+
+bool initialiseValueDistribution(const std::string& distribution_name,
+                                 const std::string& value_name,
+                                 const double min_value_limit,
+                                 const double max_value_limit,
+                                 const double base_value_limit,
+                                 HighsValueDistribution& value_distribution);
+
+bool updateValueDistribution(const double value,
+                             HighsValueDistribution& value_distribution);
+
+HighsInt integerPercentage(const HighsInt of, const HighsInt in);
+double doublePercentage(const HighsInt of, const HighsInt in);
+
+bool logValueDistribution(const HighsLogOptions& log_options,
+                          const HighsValueDistribution& value_distribution,
+                          const HighsInt mu = 0);
+bool initialiseScatterData(const HighsInt max_num_point,
+                           HighsScatterData& scatter_data);
+bool updateScatterData(const double value0, const double value1,
+                       HighsScatterData& scatter_data);
+bool regressScatterData(HighsScatterData& scatter_data);
+bool predictFromScatterData(const HighsScatterData& scatter_data,
+                            const double value0, double& predicted_value1,
+                            const bool log_regression = false);
+bool printScatterData(const std::string& name,
+                      const HighsScatterData& scatter_data);
+void printScatterDataRegressionComparison(const std::string& name,
+                                          const HighsScatterData& scatter_data);
+bool computeScatterDataRegressionError(HighsScatterData& scatter_data,
+                                       const bool print = false);
+
+double nearestPowerOfTwoScale(const double value);
+
+// If assert_condition is false then, if NDEBUG is defined message is
+// printed and abort() is called, otherwise assert is called
+void highsAssert(const bool assert_condition, const std::string& message = "");
+
+// If pause_condition is true, then keyboard input is required. Allows
+// breakpoints in VScode where optimization might prevent them.
+bool highsPause(const bool pause_condition, const std::string& message = "");
+
+// Utility for computing fractional part
+template <typename T>
+inline T fractionality(T input, T* intval = nullptr) {
+  using std::abs;
+  using std::round;
+  T val = round(input);
+  if (intval != nullptr) *intval = val;
+  return abs(input - val);
+}
+
+inline std::pair<double, double> infeasibility(const double lower,
+                                               const double value,
+                                               const double upper,
+                                               const double tolerance) {
+  using std::fabs;
+  using std::min;
+  double residual = 0;
+  double infeasibility = 0;
+  // Determine the infeasibility exceeding the tolerance used in
+  // computing the number of infeasibilities in a basic solution -
+  // which defines its feasibility
+  //
+  // @primal_infeasibility calculation
+  if (value < lower - tolerance) infeasibility = lower - value;
+  if (value > upper + tolerance) infeasibility = value - upper;
+  // Determine the residual used in computing the sum of
+  // infeasibilities and max infeasibility - which are just for
+  // reporting
+  if (tolerance > 0) {
+    if (value < lower) residual = lower - value;
+    if (value > upper) residual = value - upper;
+  } else {
+    residual = infeasibility;
+  }
+  // Now, if the bound defining the residual is large, it's possible
+  // for the infeasibility to be zero, but the residual to exceed the
+  // tolerance due to numerical rounding
+  //
+  // Case in point is #2653 where row 1 has l = 157345 and the
+  // activity gives zero infeasibility, but a residual of
+  // 1.00000761449e-06, exceeding the tolerance of 1e-6 by delta =
+  // 7.61449e-12.
+  //
+  // Now delta / l = 4.83937e-17, which is less than machine precision
+  // (2.22045e-16), so the reliable residual value should ignore this
+  // delta.
+  //
+  // In general, it might be possible to subtract delta from the
+  // residual conditional on (something like)
+  //
+  // delta < 1e1 * max(1.0, fabs(bound_value)) * kHighsMacheps
+  //
+  // to give a reasonable value but, in practice, when infeasibility is
+  // 0, it would seem fine to set
+  //
+  // residual = min(residual, tolerance)
+  //
+  // so that values of maximum infeasibility defined by residual
+  // doesn't exceed the tolerance
+  //
+  if (infeasibility == 0) residual = min(residual, tolerance);
+  return std::make_pair(infeasibility, residual);
+}
+#endif  // UTIL_HIGHSUTILS_H_

data/ext/lpsolver-highs/highs/util/stringutil.cpp

@@ -0,0 +1,131 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "util/stringutil.h"
+
+#include <algorithm>  // for std::transform
+#include <cassert>
+#include <cctype>
+
+/*
+void strRemoveWhitespace(char* str) {
+  char* dest = str;
+  do
+    while (isspace(*str)) str++;
+  while ((*dest++ = *str++));
+}
+
+char* strClone(const char* str) {
+  size_t n;
+  n = strlen(str);
+
+  char* cpy = new char[n + 1];
+  strcpy(cpy, str);
+  return cpy;
+}
+
+int strIsWhitespace(const char* str) {
+  while (*str != '\0') {
+    if (!isspace((unsigned char)*str)) {
+      return 0;
+    }
+    str++;
+  }
+  return 1;
+}
+
+void strToLower(char* str) {
+  int i;
+  for (i = 0; str[i] != '\0'; i++) {
+    str[i] = (char)tolower(str[i]);
+  }
+}
+
+void strTrim(char* str) {
+  int i;
+  int begin = 0;
+  int end = strlen(str) - 1;
+
+  while (isspace((unsigned char)str[begin])) begin++;
+
+  while ((end >= begin) && isspace((unsigned char)str[end])) end--;
+
+  // Shift all characters back to the start of the string array.
+  for (i = begin; i <= end; i++) str[i - begin] = str[i];
+
+  str[i - begin] = '\0';  // Null terminate string.
+}
+*/
+
+// std::string& str_tolower(std::string str) {
+//   std::transform(str.begin(), str.end(), str.begin(),
+//                  [](unsigned char c) { return std::tolower(c); }  // correct
+//   );
+//   return str;
+// }
+
+void tolower(std::string& str) {
+  std::transform(str.begin(), str.end(), str.begin(),
+                 [](unsigned char c) { return std::tolower(c); });
+}
+
+void toupper(std::string& str) {
+  std::transform(str.begin(), str.end(), str.begin(),
+                 [](unsigned char c) { return std::toupper(c); });
+}
+
+std::string& ltrim(std::string& str, const std::string& chars) {
+  str.erase(0, str.find_first_not_of(chars));
+  return str;
+}
+
+std::string& rtrim(std::string& str, const std::string& chars) {
+  str.erase(str.find_last_not_of(chars) + 1);
+  return str;
+}
+
+std::string& trim(std::string& str, const std::string& chars) {
+  return ltrim(rtrim(str, chars), chars);
+}
+
+bool is_empty(char c, const std::string& chars) {
+  size_t pos = chars.find_first_of(c);
+  if (pos == std::string::npos || pos == chars.size()) return false;
+  return true;
+}
+
+bool is_empty(std::string& str, const std::string& chars) {
+  size_t pos = str.find_first_not_of(chars);
+  if (pos == std::string::npos || pos == str.size()) return true;
+  return false;
+}
+
+bool is_end(std::string& str, size_t end, const std::string& chars) {
+  size_t pos = str.find_first_not_of(chars, end);
+  if (pos == std::string::npos || pos == str.size()) return true;
+  return false;
+}
+
+size_t first_word_end(std::string& str, size_t start) {
+  const std::string chars = "\t\n\v\f\r ";
+  size_t next_word_start = str.find_first_not_of(chars, start);
+  size_t next_word_end = str.find_first_of(chars, next_word_start);
+  if (next_word_end == std::string::npos || next_word_end > str.size())
+    return str.size();
+  return next_word_end;
+}
+
+std::string first_word(std::string& str, size_t start) {
+  // If start is (at least) the length of str, then next_word_start is
+  // negative, so there's no word, so return ""
+  if (start >= str.length()) return "";
+  const std::string chars = "\t\n\v\f\r ";
+  size_t next_word_start = str.find_first_not_of(chars, start);
+  size_t next_word_end = str.find_first_of(chars, next_word_start);
+  assert(next_word_start != std::string::npos);
+  return str.substr(next_word_start, next_word_end - next_word_start);
+}

data/ext/lpsolver-highs/highs/util/stringutil.h

@@ -0,0 +1,46 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef STRINGUTIL_H
+#define STRINGUTIL_H
+
+#include <ctype.h>
+
+#include <cstring>
+#include <string>
+
+/*
+void strRemoveWhitespace(char* str);
+char* strClone(const char* str);
+int strIsWhitespace(const char* str);
+void strToLower(char* str);
+void strTrim(char* str);
+*/
+// std::string& str_tolower(std::string s);
+
+void tolower(std::string& str);
+void toupper(std::string& str);
+
+const std::string default_non_chars = "\t\n\v\f\r ";
+std::string& ltrim(std::string& str,
+                   const std::string& chars = default_non_chars);
+std::string& rtrim(std::string& str,
+                   const std::string& chars = default_non_chars);
+std::string& trim(std::string& str,
+                  const std::string& chars = default_non_chars);
+
+bool is_empty(std::string& str, const std::string& chars = default_non_chars);
+bool is_empty(char c, const std::string& chars = default_non_chars);
+bool is_end(std::string& str, size_t end,
+            const std::string& chars = default_non_chars);
+
+// todo: replace with pair of references rather than string ret value to avoid
+// copy and also using function below. or do it properly with iterators.
+std::string first_word(std::string& str, size_t start);
+size_t first_word_end(std::string& str, size_t start);
+
+#endif

data/ext/lpsolver-highs/highs.pc.in

@@ -0,0 +1,12 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@/highs
+
+Name: HiGHS
+Description: Linear Optimization Software
+URL: https://github.com/ERGO-Code/HiGHS
+Version: @HIGHS_VERSION_MAJOR@.@HIGHS_VERSION_MINOR@.@HIGHS_VERSION_PATCH@
+Libs: -L${libdir} -lhighs
+#TODO Libs.private (when HiGHS lib is build as static lib)
+Cflags: -I${includedir}
+Requires:

data/ext/lpsolver-highs/meson.build

@@ -0,0 +1,198 @@
+project('highs', 'cpp', 'c',
+  version : '1.14.0',
+  meson_version: '>= 1.1.0',
+  default_options : ['warning_level=1',
+                     'cpp_std=c++17',
+                     'wrap_mode=forcefallback',
+                     'highsint64=false'])
+
+
+# Add C++ compiler options
+_args = [] # Extra arguments
+_deps = [] # Dependencies
+_incdirs = [] # All the includes
+
+cc = meson.get_compiler('c')
+cppc = meson.get_compiler('cpp')
+
+# Platform detection
+host_system = host_machine.system()
+is_windows = host_system == 'windows'
+is_mingw = is_windows and cc.get_id() == 'gcc'
+
+# Granular flags
+# C++
+_cpp_Wno_invalid_offsetof = cppc.get_supported_arguments('-Wno-invalid-offsetof')
+_cpp_Wno_maybe_uninitialized = cppc.get_supported_arguments('-Wno-maybe-uninitialized')
+_cpp_Wno_reorder = cppc.get_supported_arguments('-Wno-reorder')
+_cpp_Wno_reorder_ctor = cppc.get_supported_arguments('-Wno-reorder-ctor')
+_cpp_Wno_sometimes_uninitialized = cppc.get_supported_arguments('-Wno-sometimes-uninitialized')
+_cpp_Wno_unused_but_set_variable = cppc.get_supported_arguments('-Wno-unused-but-set-variable')
+_cpp_Wno_unused_variable = cppc.get_supported_arguments('-Wno-unused-variable')
+_cpp_Wno_use_after_free = cppc.get_supported_arguments('-Wno-use-after-free')
+_cpp_Wno_comment = cppc.get_supported_arguments('-Wno-comment')
+
+
+# C
+Wno_comment = cc.get_supported_arguments('-Wno-comment')
+Wno_invalid_offsetof = cc.get_supported_arguments('-Wno-invalid-offsetof')
+Wno_maybe_uninitialized = cc.get_supported_arguments('-Wno-maybe-uninitialized')
+Wno_sometimes_uninitialized = cc.get_supported_arguments('-Wno-sometimes-uninitialized')
+Wno_unused_label = cc.get_supported_arguments('-Wno-unused-label')
+Wno_unused_but_set_variable = cc.get_supported_arguments('-Wno-unused-but-set-variable')
+Wno_unused_variable = cc.get_supported_arguments('-Wno-unused-variable')
+Wno_use_after_free = cc.get_supported_arguments('-Wno-use-after-free')
+
+# Conditional arguments
+_highs_cpp_suppressions = [
+  _cpp_Wno_comment,
+  _cpp_Wno_invalid_offsetof,
+  _cpp_Wno_maybe_uninitialized,
+  _cpp_Wno_reorder,
+  _cpp_Wno_reorder_ctor,
+  _cpp_Wno_sometimes_uninitialized,
+  _cpp_Wno_unused_but_set_variable,
+  _cpp_Wno_unused_variable,
+  _cpp_Wno_use_after_free,
+]
+
+_highs_c_suppressions = [
+  Wno_comment,
+  Wno_invalid_offsetof,
+  Wno_maybe_uninitialized,
+  Wno_sometimes_uninitialized,
+  Wno_unused_but_set_variable,
+  Wno_unused_label,
+  Wno_unused_variable,
+  Wno_use_after_free,
+]
+
+
+if cppc.get_id() == 'msvc'
+  add_project_arguments(
+      '/wd4018',  # Disable warning: 'expression' : signed/unsigned mismatch
+      '/wd4061',  # Disable warning: enumerator 'identifier' in switch of enum 'enumeration' is not explicitly handled by a case label
+      '/wd4100',  # Disable warning: 'identifier' : unreferenced formal parameter
+      '/wd4101',  # Disable warning: 'identifier' : unreferenced local variable
+      '/wd4127',  # Disable warning: conditional expression is constant
+      '/wd4189',  # Disable warning: 'identifier' : local variable is initialized but not referenced
+      '/wd4244',  # Disable warning: 'conversion' conversion from 'type1' to 'type2', possible loss of data
+      '/wd4245',  # Disable warning: 'conversion' conversion from 'type1' to 'type2', signed/unsigned mismatch
+      '/wd4267',  # Disable warning: 'conversion' conversion from 'size_t' to 'type', possible loss of data
+      '/wd4324',  # Disable warning: 'structure' structure was padded due to alignment specifier
+      '/wd4365',  # Disable warning: 'action' : conversion from 'type_1' to 'type_2', signed/unsigned mismatch
+      '/wd4389',  # Disable warning: 'modifier' : signed/unsigned mismatch
+      '/wd4456',  # Disable warning: declaration of 'identifier' hides previous local declaration
+      '/wd4457',  # Disable warning: declaration of 'identifier' hides function parameter
+      '/wd4458',  # Disable warning: declaration of 'identifier' hides class member
+      '/wd4459',  # Disable warning: declaration of 'identifier' hides global declaration
+      '/wd4514',  # Disable warning: 'function' : unreferenced inline function has been removed
+      '/wd4701',  # Disable warning: potentially uninitialized local variable 'name' used
+      '/wd4820',  # Disable warning: 'bytes' bytes padding added after construct 'member_name'
+      language: 'cpp',
+  )
+  _args += '-D_CRT_SECURE_NO_WARNINGS'
+endif
+
+cpu_family = host_machine.cpu_family()
+
+if cpu_family in ['x86_64', 'i686'] and not is_windows
+    add_project_arguments(cppc.get_supported_arguments('-mpopcnt'), language: 'cpp')
+endif
+if cpu_family in ['ppc64', 'powerpc64'] and not meson.is_cross_build()
+    add_project_arguments(cppc.get_supported_arguments('-mpopcntd'), language: 'cpp')
+endif
+
+if is_mingw
+  # For mingw-w64, don't use LTO 
+  add_project_arguments('-fno-use-linker-plugin', language: ['c', 'cpp'])
+endif
+
+# --------------------- Dependencies
+threads_dep = dependency('threads', required: false)
+_deps += threads_dep
+
+# Determine whether it is necessary to link libatomic. This could be the case
+# e.g. on 32-bit platforms when atomic operations are used on 64-bit types.
+# The check is copied from SciPy which in turn came from
+# Mesa <https://www.mesa3d.org/>.
+null_dep = dependency('', required : false)
+atomic_dep = null_dep
+code_non_lockfree = '''
+  #include <stdint.h>
+  int main() {
+   struct {
+     uint64_t *v;
+   } x;
+   return (int)__atomic_load_n(x.v, __ATOMIC_ACQUIRE) &
+          (int)__atomic_add_fetch(x.v, (uint64_t)1, __ATOMIC_ACQ_REL);
+  }
+'''
+if cc.get_id() != 'msvc'
+  if not cc.links(
+      code_non_lockfree,
+      name : 'Check atomic builtins without -latomic'
+    )
+    atomic_dep = cc.find_library('atomic', required: false)
+    if atomic_dep.found()
+      # From SciPy
+      # We're not sure that with `-latomic` things will work for all compilers,
+      # so verify and only keep libatomic as a dependency if this works.
+      if not cc.links(
+          code_non_lockfree,
+          dependencies: atomic_dep,
+          name : 'Check atomic builtins with -latomic'
+        )
+        atomic_dep = null_dep
+      endif
+    endif
+  endif
+endif
+
+_deps += atomic_dep
+
+# Optional
+zlib_dep = dependency('zlib',
+                      required: get_option('use_zlib'))
+if zlib_dep.found()
+  _deps += zlib_dep
+  _incdirs += include_directories(['extern/zstr'])
+endif
+
+# Include Sources
+_incdirs += include_directories([
+  'extern/',
+  'extern/pdqsort/',
+])
+
+# Optional arguments
+if get_option('fast_build')
+  add_project_arguments(cc.get_supported_arguments('-fno-omit-frame-pointer'), language : ['c', 'cpp'])
+endif
+
+if get_option('debug_sol')
+  _args += ['-DHIGHS_DEBUGSOL']
+endif
+
+if cppc.get_id() == 'msvc'
+  # Don't depend on VCRUNTIME140_1.dll
+  # https://cibuildwheel.readthedocs.io/en/stable/faq/#windows-importerror-dll-load-failed-the-specific-module-could-not-be-found
+  add_project_arguments('/d2FH4-', language : ['cpp', 'c'])
+  if get_option('with_stdcall')
+    add_project_arguments(cppc.get_supported_arguments('/Gz'), language : ['cpp', 'c'])
+  endif
+endif
+
+# --------------------- Library
+
+subdir('highs') # defines highslib
+
+# --------------------- Tests
+
+if get_option('with_tests')
+  subdir('check')
+  _deps += dependency('catch2', required: true)
+endif
+
+# --------------------- Bindings
+# now in highs/

data/ext/lpsolver-highs/meson_options.txt

@@ -0,0 +1,31 @@
+# Booleans
+option('fast_build',
+       type : 'boolean',
+       value : false)
+option('highsint64',
+       type : 'boolean',
+       value : true)
+option('use_zlib',
+       type : 'feature')
+option('with_fortran',
+       type : 'boolean',
+       value : false)
+option('with_csharp',
+       type : 'boolean',
+       value : false)
+option('debug_sol',
+      type: 'boolean',
+      value: false)
+option('with_stdcall',
+      type: 'boolean',
+      description: 'Build highs with the __stdcall convention',
+      value: false)
+option('with_tests',
+      type: 'boolean',
+      value: false)
+option('with_pybind11',
+       type : 'boolean',
+       value : false)
+option('do_install',
+       type : 'boolean',
+       value : true)