lpsolver 0.1.0 → 0.2.1

data/ext/lpsolver-highs/app/CMakeLists.txt

@@ -0,0 +1,110 @@
+if(FAST_BUILD)
+  if (BUILD_CXX_EXE)
+    # Configure the config windows version file
+    if(MSVC)
+      string(REPLACE "." ","  PROJECT_RC_VERSION "${PROJECT_VERSION}")
+      configure_file(${PROJECT_SOURCE_DIR}/version.rc.in
+        "${HIGHS_BINARY_DIR}/version.rc" @ONLY)
+      set(win_version_file ${HIGHS_BINARY_DIR}/version.rc)
+    else()
+      set(win_version_file)
+    endif()
+
+    add_executable(highs-bin)
+    target_sources(highs-bin PRIVATE RunHighs.cpp HighsRuntimeOptions.h ${win_version_file})
+
+    target_include_directories(highs-bin PRIVATE
+      $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/app>
+    )
+
+    set_target_properties(highs-bin PROPERTIES POSITION_INDEPENDENT_CODE ON)
+
+    if(UNIX)
+      target_compile_options(highs-bin PUBLIC "-Wno-unused-variable")
+      target_compile_options(highs-bin PUBLIC "-Wno-unused-const-variable")
+    endif()
+
+    set_target_properties(highs-bin PROPERTIES OUTPUT_NAME highs)
+    set_target_properties(highs-bin PROPERTIES UNITY_BUILD OFF)
+
+    target_compile_features(highs-bin PRIVATE cxx_std_11)
+    target_link_libraries(highs-bin PRIVATE ${PROJECT_NAMESPACE}::highs)
+
+    include(GNUInstallDirs)
+
+    if (NOT BUILD_STATIC_EXE)
+      if(APPLE)
+          set_target_properties(highs-bin PROPERTIES INSTALL_RPATH
+          "@loader_path/../${CMAKE_INSTALL_LIBDIR};@loader_path")
+      elseif (UNIX)
+          set_target_properties(highs-bin PROPERTIES INSTALL_RPATH
+          "$ORIGIN:$ORIGIN/../${CMAKE_INSTALL_LIBDIR}")
+
+        # cmake_path is 3.20, leave for later.
+        # cmake_path(RELATIVE_PATH CMAKE_INSTALL_FULL_LIBDIR
+        #        BASE_DIRECTORY ${CMAKE_INSTALL_FULL_BINDIR}
+        #        OUTPUT_VARIABLE libdir_relative_path)
+        # set_target_properties(highs-bin PROPERTIES INSTALL_RPATH
+        #   "$ORIGIN/${libdir_relative_path}")
+      endif()
+    else()
+      # Remove or disable any SET_TARGET_PROPERTIES for RPATH on the static binary
+      # Or add this after the install command:
+      set_target_properties(highs-bin PROPERTIES
+          SKIP_BUILD_RPATH TRUE
+          SKIP_INSTALL_RPATH TRUE
+      )
+    endif()
+
+    if(WIN32 AND HIPO AND BUILD_OPENBLAS AND BUILD_SHARED_LIBS)
+      add_custom_command(TARGET highs-bin POST_BUILD
+          COMMAND ${CMAKE_COMMAND} -E copy_if_different
+          $<TARGET_FILE:openblas>
+          $<TARGET_FILE_DIR:highs-bin>
+      )
+    endif()
+
+    # install the binary
+    install(TARGETS highs-bin
+      EXPORT highs-target
+      RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+      COMPONENT cli)
+
+    if(BUILD_TESTING)
+      if (APPLE)
+        set(CMAKE_INSTALL_RPATH
+                "@loader_path/../${CMAKE_INSTALL_LIBDIR};@loader_path")
+      elseif (UNIX)
+        set(CMAKE_INSTALL_RPATH "$ORIGIN/../${CMAKE_INSTALL_LIBDIR}:$ORIGIN:$ORIGIN/../lib:$ORIGIN")
+      endif ()
+    endif()
+
+  endif()
+else()
+  # create highs binary using library without pic
+  add_executable(highs)
+
+  target_sources(highs PRIVATE RunHighs.cpp)
+
+  if(UNIX)
+    target_compile_options(highs PUBLIC "-Wno-unused-variable")
+    target_compile_options(highs PUBLIC "-Wno-unused-const-variable")
+  endif()
+
+  target_link_libraries(highs libhighs)
+
+  target_include_directories(highs PRIVATE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/app>
+  )
+
+  set_target_properties(highs PROPERTIES UNITY_BUILD OFF)
+  # install the binary
+  install(TARGETS highs EXPORT highs-targets
+    RUNTIME)
+endif()
+
+# Add demo to FAST_BUILD as well.
+if(EMSCRIPTEN AND EMSCRIPTEN_HTML)
+  set(CMAKE_EXECUTABLE_SUFFIX ".html")
+  set_target_properties(highs PROPERTIES LINK_DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/highs_webdemo_shell.html)
+endif()

data/ext/lpsolver-highs/app/HighsRuntimeOptions.h

@@ -0,0 +1,292 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    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                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#ifndef LP_DATA_HIGHSRUNTIMEOPTIONS_H_
+#define LP_DATA_HIGHSRUNTIMEOPTIONS_H_
+
+#include <cassert>
+
+#include "../extern/CLI11.hpp"
+#include "HConfig.h"
+#include "io/HighsIO.h"
+#include "io/LoadOptions.h"
+#include "util/stringutil.h"
+
+struct HighsCommandLineOptions {
+  bool cmd_version = false;
+  double cmd_time_limit = 0;
+  int cmd_random_seed = 0;
+
+  std::string model_file = "";
+  std::string cmd_read_basis_file = "";
+  std::string cmd_write_basis_file = "";
+  std::string options_file = "";
+  std::string cmd_read_solution_file = "";
+  std::string cmd_presolve = "";
+  std::string cmd_solver = "";
+  std::string cmd_parallel = "";
+  std::string cmd_crossover = "";
+  std::string cmd_write_solution_file = "";
+  std::string cmd_write_model_file = "";
+  std::string cmd_ranging = "";
+};
+
+void setupCommandLineOptions(CLI::App& app,
+                             HighsCommandLineOptions& cmd_options) {
+  // Does not work on windows with spaces in directory or file names.
+  // const auto checkSingle = [](const std::string& input) -> std::string {
+  //   if (input.find(' ') != std::string::npos) {
+  //     return "Multiple files not implemented.";
+  //   }
+  //   return {};
+  // };
+
+  // Command line file specifications.
+  app.add_option("--" + kModelFileString + "," + kModelFileString,
+                 cmd_options.model_file, "File of model to solve.")
+      // Can't use required here because it breaks version printing with -v.
+      // ->required()
+      // ->check(checkSingle)
+      ->check(CLI::ExistingFile);
+
+  app.add_option("--" + kOptionsFileString, cmd_options.options_file,
+                 "File containing HiGHS options.")
+      // ->check(checkSingle)
+      ->check(CLI::ExistingFile);
+
+  app.add_option("--" + kReadSolutionFileString,
+                 cmd_options.cmd_read_solution_file,
+                 "File of solution to read.")
+      // ->check(checkSingle)
+      ->check(CLI::ExistingFile);
+
+  app.add_option("--" + kReadBasisFileString, cmd_options.cmd_read_basis_file,
+                 "File of initial basis to read.")
+      // ->check(checkSingle)
+      ->check(CLI::ExistingFile);
+
+  app.add_option("--" + kWriteModelFileString, cmd_options.cmd_write_model_file,
+                 "File for writing out model.");
+  // File does not need to exist
+  //      ->check(CLI::ExistingFile)
+  // ->check(checkSingle);
+
+  app.add_option("--" + kWriteSolutionFileString,
+                 cmd_options.cmd_write_solution_file,
+                 "File for writing out solution.");
+  // File does not need to exist
+  //      ->check(CLI::ExistingFile)
+  // ->check(checkSingle);
+
+  app.add_option("--" + kWriteBasisFileString, cmd_options.cmd_write_basis_file,
+                 "File for writing out final basis.");
+  // File does not need to exist
+  //      ->check(CLI::ExistingFile)
+  // ->check(checkSingle);
+
+  // Command line option specifications.
+  app.add_option("--" + kPresolveString, cmd_options.cmd_presolve,
+                 "Set presolve option to:\n"
+                 "\"choose\" * default\n"
+                 "\"on\"\n"
+                 "\"off\"");
+
+  app.add_option("--" + kSolverString, cmd_options.cmd_solver,
+                 "Set solver option to:\n"
+                 "\"choose\" * default\n"
+                 "\"simplex\"\n"
+#ifdef HIPO
+                 "\"hipo\"\n"
+#endif
+                 "\"ipm\"");
+
+  app.add_option("--" + kParallelString, cmd_options.cmd_parallel,
+                 "Set parallel option to:\n"
+                 "\"choose\" * default\n"
+                 "\"on\"\n"
+                 "\"off\"");
+
+  app.add_option("--" + kRunCrossoverString, cmd_options.cmd_crossover,
+                 "Set run_crossover option to:\n"
+                 "\"choose\"\n"
+                 "\"on\" * default\n"
+                 "\"off\"");
+
+  app.add_option("--" + kTimeLimitString, cmd_options.cmd_time_limit,
+                 "Run time limit (seconds - double).");
+
+  app.add_option("--" + kRandomSeedString, cmd_options.cmd_random_seed,
+                 "Seed to initialize random number \ngeneration.");
+
+  app.add_option("--" + kRangingString, cmd_options.cmd_ranging,
+                 "Compute cost, bound, RHS and basic \nsolution ranging:\n"
+                 "\"on\"\n"
+                 "\"off\" * default");
+
+  // Version.
+  app.add_flag("--version,-v", cmd_options.cmd_version, "Print version.");
+  app.set_help_flag("-h,--help", "Print help.");
+
+  app.get_formatter()->column_width(33);
+
+  app.get_formatter()->label("TEXT:FILE", "file");
+  app.get_formatter()->label("TEXT", "text");
+  app.get_formatter()->label("FLOAT", "float");
+  app.get_formatter()->label("INT", "int");
+  app.get_formatter()->label("OPTIONS", "options");
+}
+
+bool loadOptions(const CLI::App& app, const HighsLogOptions& report_log_options,
+                 const HighsCommandLineOptions& c, HighsOptions& options) {
+  if (c.cmd_version) {
+    std::cout << "HiGHS version " << HIGHS_VERSION_MAJOR << "."
+              << HIGHS_VERSION_MINOR << "." << HIGHS_VERSION_PATCH;
+    std::cout << " Githash " << HIGHS_GITHASH << ". ";
+    std::cout << kHighsCopyrightStatement << std::endl;
+    exit(0);
+  }
+
+  // Options file.
+  if (c.options_file != "") {
+    switch (loadOptionsFromFile(report_log_options, options, c.options_file)) {
+      case HighsLoadOptionsStatus::kError:
+        return false;
+      case HighsLoadOptionsStatus::kEmpty:
+        writeOptionsToFile(stdout, options.log_options, options.records);
+        return false;
+      default:
+        break;
+    }
+  }
+
+  // Read solution file option.
+  if (c.cmd_read_solution_file != "") {
+    if (setLocalOptionValue(report_log_options, kReadSolutionFileString,
+                            options.log_options, options.records,
+                            c.cmd_read_solution_file) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Read basis file option.
+  if (c.cmd_read_basis_file != "") {
+    if (setLocalOptionValue(report_log_options, kReadBasisFileString,
+                            options.log_options, options.records,
+                            c.cmd_read_basis_file) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Write model file option.
+  if (c.cmd_write_model_file != "") {
+    if (setLocalOptionValue(report_log_options, kWriteModelFileString,
+                            options.log_options, options.records,
+                            c.cmd_write_model_file) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Write solution file option.
+  if (c.cmd_write_solution_file != "") {
+    if (setLocalOptionValue(report_log_options, kWriteSolutionFileString,
+                            options.log_options, options.records,
+                            c.cmd_write_solution_file) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Write basis file option.
+  if (c.cmd_write_basis_file != "") {
+    if (setLocalOptionValue(report_log_options, kWriteBasisFileString,
+                            options.log_options, options.records,
+                            c.cmd_write_basis_file) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Handle command line option specifications.
+  // Presolve option.
+  if (c.cmd_presolve != "") {
+    if (setLocalOptionValue(report_log_options, kPresolveString,
+                            options.log_options, options.records,
+                            c.cmd_presolve) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Solver option.
+  if (c.cmd_solver != "") {
+    if (setLocalOptionValue(report_log_options, kSolverString,
+                            options.log_options, options.records,
+                            c.cmd_solver) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Parallel option.
+  if (c.cmd_parallel != "") {
+    if (setLocalOptionValue(report_log_options, kParallelString,
+                            options.log_options, options.records,
+                            c.cmd_parallel) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Run crossover option.
+  if (c.cmd_crossover != "") {
+    if (setLocalOptionValue(report_log_options, kRunCrossoverString,
+                            options.log_options, options.records,
+                            c.cmd_crossover) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Time limit option.
+  if (app.count("--" + kTimeLimitString) > 0) {
+    if (setLocalOptionValue(report_log_options, kTimeLimitString,
+                            options.records,
+                            c.cmd_time_limit) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Random seed option.
+  if (app.count("--" + kRandomSeedString) > 0) {
+    HighsInt value = c.cmd_random_seed;
+    if (setLocalOptionValue(report_log_options, kRandomSeedString,
+                            options.records, value) != OptionStatus::kOk)
+      return false;
+  }
+
+  // Ranging option.
+  if (c.cmd_ranging != "") {
+    if (setLocalOptionValue(report_log_options, kRangingString,
+                            options.log_options, options.records,
+                            c.cmd_ranging) != OptionStatus::kOk)
+      return false;
+  }
+
+  // If this horrible hack is still needed, please add it to RunHighs.
+  // model_file is now const in this method.
+
+  // const bool horrible_hack_for_windows_visual_studio = false;
+  // if (horrible_hack_for_windows_visual_studio) {
+  //   // Until I know how to debug an executable using command line
+  //   // arguments in Visual Studio on Windows, this is necessary!
+  //   HighsInt random_seed = -3;
+  //   if (random_seed >= 0) {
+  //     if (setLocalOptionValue(report_log_options, kRandomSeedString,
+  //                             options.records,
+  //                             random_seed) != OptionStatus::kOk)
+  //       return false;
+  //   }
+  //   model_file = "ml.mps";
+  // }
+
+  if (c.model_file.size() == 0) {
+    std::cout << "Please specify filename in .mps|.lp|.ems format.\n";
+    return false;
+  }
+
+  return true;
+}
+
+#endif

data/ext/lpsolver-highs/app/RunHighs.cpp

@@ -0,0 +1,147 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file ../app/RunHighs.cpp
+ * @brief HiGHS main
+ */
+#include <cstdio>  // For fclose
+
+#include "Highs.h"
+#include "HighsRuntimeOptions.h"
+
+static bool written_cli_copyright_line = false;
+
+void cliCopyrightLine(const HighsLogOptions& log_options) {
+  if (written_cli_copyright_line) return;
+  highsLogUser(log_options, HighsLogType::kInfo,
+               "Command line parsed using CLI11 %s: Copyright (c) 2017-2025 "
+               "University of Cincinnati\n",
+               CLI11_VERSION);
+  written_cli_copyright_line = true;
+}
+
+int runHighsReturn(Highs& highs, const int status) {
+  // Possibly write out the HiGHS and CLI copyright lines
+  highs.logHeader();
+  cliCopyrightLine(highs.getOptions().log_options);
+  // Close any log file explicitly
+  highs.closeLogFile();
+  // Check that the log file has been closed
+  assert(highs.getOptions().log_options.log_stream == nullptr);
+  return status;
+}
+
+int runHighsReturn(Highs& highs, const HighsStatus status) {
+  return runHighsReturn(highs, int(status));
+}
+
+int main(int argc, char** argv) {
+  // Create the Highs instance.
+  Highs highs;
+  const HighsOptions& options = highs.getOptions();
+  const HighsLogOptions& log_options = options.log_options;
+
+  // Load user options.
+  HighsCommandLineOptions cmd_options;
+  HighsOptions loaded_options;
+
+  // Set kHighsRunLogFile as the default log_file for the app so that
+  // log_file has this value if it isn't set in the file
+  loaded_options.log_file = kHighsRunLogFile;
+  // When loading the options file, any messages are reported using
+  // the default HighsLogOptions
+
+  CLI::App app{""};
+  argv = app.ensure_utf8(argv);
+
+  setupCommandLineOptions(app, cmd_options);
+
+  try {
+    std::string usage_msg =
+        "usage:\n      " + std::string(argv[0]) + " [options] [file]";
+    app.usage(usage_msg);
+
+    app.parse(argc, argv);
+  } catch (const CLI::CallForHelp& e) {
+    std::cout << app.help() << std::endl;
+    return runHighsReturn(highs, 0);
+  } catch (const CLI::CallForAllHelp& e) {
+    std::cout << app.help();
+    return runHighsReturn(highs, 0);
+  } catch (const CLI::RequiredError& e) {
+    std::cout << "Please specify filename in .mps|.lp|.ems format."
+              << std::endl;
+    return runHighsReturn(highs, HighsStatus::kError);
+  } catch (const CLI::ExtrasError& e) {
+    std::cout << e.what() << std::endl;
+    std::cout << "Multiple files not supported." << std::endl;
+    return runHighsReturn(highs, HighsStatus::kError);
+  } catch (const CLI::ArgumentMismatch& e) {
+    std::cout << e.what() << std::endl;
+    std::cout << "Too many arguments provided. Please provide only one."
+              << std::endl;
+    return runHighsReturn(highs, HighsStatus::kError);
+  } catch (const CLI::ParseError& e) {
+    std::cout << e.what() << std::endl;
+    // app.exit() should be called from main.
+    return runHighsReturn(highs, app.exit(e));
+  }
+
+  if (!loadOptions(app, log_options, cmd_options, loaded_options))
+    return runHighsReturn(highs, HighsStatus::kError);
+
+  // Open the app log file - unless output_flag is false, to avoid
+  // creating an empty file. It does nothing if its name is "".
+  if (loaded_options.output_flag) highs.openLogFile(loaded_options.log_file);
+
+  // Pass the option settings to HiGHS. Only error-checking produces
+  // output, but values are checked in loadOptions, so it's safe to
+  // call this first so that Highs::logHeader() uses reporting
+  // settings defined in any options file.
+  highs.passOptions(loaded_options);
+
+  highs.logHeader();
+  // Acknowledge use of CLI for command line parsing
+  cliCopyrightLine(log_options);
+  // Log changes from the default option settings
+  highs.writeOptions("", true);
+
+  // Load the model from model_file
+  HighsStatus read_status = highs.readModel(cmd_options.model_file);
+  if (read_status == HighsStatus::kError) {
+    highsLogUser(log_options, HighsLogType::kInfo, "Error loading file\n");
+    return runHighsReturn(highs, read_status);
+  }
+
+  if (options.write_presolved_model_file != "") {
+    // Run presolve and write the presolved model to a file
+    HighsStatus status = highs.presolve();
+    if (status == HighsStatus::kError) return runHighsReturn(highs, status);
+    HighsPresolveStatus model_presolve_status = highs.getModelPresolveStatus();
+    const bool ok_to_write =
+        model_presolve_status == HighsPresolveStatus::kNotReduced ||
+        model_presolve_status == HighsPresolveStatus::kReduced ||
+        model_presolve_status == HighsPresolveStatus::kReducedToEmpty ||
+        model_presolve_status == HighsPresolveStatus::kTimeout;
+    if (!ok_to_write) {
+      highsLogUser(log_options, HighsLogType::kInfo,
+                   "No presolved model to write to file\n");
+      return runHighsReturn(highs, status);
+    }
+    status = highs.writePresolvedModel(options.write_presolved_model_file);
+    return runHighsReturn(highs, status);
+  }
+  // Solve the model
+  HighsStatus run_status = highs.run();
+  if (run_status == HighsStatus::kError) runHighsReturn(highs, run_status);
+
+  // Shut down task executor for explicit release of memory.
+  // Valgrind still reachable otherwise.
+  highs.resetGlobalScheduler(true);
+
+  return runHighsReturn(highs, run_status);
+}

data/ext/lpsolver-highs/app/highs_webdemo_shell.html

@@ -0,0 +1,73 @@
+<!doctype html>
+<!-- compare https://github.com/emscripten-core/emscripten/blob/main/src/shell_minimal.html -->
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+    <title>HiGHS</title>
+  </head>
+  <body>
+    <div style="display: grid; grid-template-columns: 1fr 1fr">
+      <textarea id="input" style="height: 700px">
+      </textarea>    
+      <textarea id="output"></textarea>    
+      <button id="run">Optimize!</button>
+    </div>
+    {{{ SCRIPT }}}
+    <script type='text/javascript'>
+      main = async () => {
+        const printInTextarea = function(text) {
+          if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' ');
+          // These replacements are necessary if you render to raw HTML
+          //text = text.replace(/&/g, "&amp;");
+          //text = text.replace(/</g, "&lt;");
+          //text = text.replace(/>/g, "&gt;");
+          //text = text.replace('\n', '<br>', 'g');
+          // console.log(text);
+          if (element) {
+            element.value += text + "\n";
+            element.scrollTop = element.scrollHeight; // focus on bottom
+          }
+        }
+
+        const highs = await HiGHS({
+          print: printInTextarea,
+          printErr: printInTextarea
+        })        
+
+        const inputTextarea = document.getElementById('input');
+        inputTextarea.value = `Maximize 
+ obj: x1 + 2 x2 + 3 x3 + x4
+Subject To
+ c1: - x1 + x2 + x3 + 10 x4 <= 20
+ c2: x1 - 3 x2 + x3 <= 30
+ c3: x2 - 3.5 x4 = 0
+Bounds
+ 0 <= x1 <= 40
+ 2 <= x4 <= 3
+General
+ x4
+End`;
+
+        const element = document.getElementById('output');
+        const clearOutput = (v) => {
+          element.value = v || '';
+        }
+
+        clearOutput('Click on "Optimize!"') // clear browser cache
+
+        const runButton = document.getElementById('run');
+        runButton.addEventListener("click", () => {
+          clearOutput()
+          const inputFilename = 'inputFile.lp'
+          highs.FS.writeFile(inputFilename, inputTextarea.value)
+          highs.callMain([inputFilename])
+        })
+
+      }
+
+      main()
+
+    </script>
+  </body>
+</html>

data/ext/lpsolver-highs/build/include/highs/HConfig.h

@@ -0,0 +1,22 @@
+#ifndef HCONFIG_H_
+#define HCONFIG_H_
+
+#define FAST_BUILD
+#define ZLIB_FOUND
+#define CUPDLP_CPU
+/* #undef CUPDLP_GPU */
+/* #undef HIPO */
+#define CMAKE_BUILD_TYPE "Release"
+/* #undef HIGHSINT64 */
+/* #undef HIGHS_NO_DEFAULT_THREADS */
+#define HIGHS_HAVE_MM_PAUSE
+#define HIGHS_HAVE_BUILTIN_CLZ
+/* #undef HIGHS_HAVE_BITSCAN_REVERSE */
+/* #undef BLAS_LIBRARIES */
+
+#define HIGHS_GITHASH "7df0786"
+#define HIGHS_VERSION_MAJOR 1
+#define HIGHS_VERSION_MINOR 14
+#define HIGHS_VERSION_PATCH 0
+
+#endif /* HCONFIG_H_ */