lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/lp_data/HighsSolve.h

@@ -0,0 +1,29 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file lp_data/HighsSolve.h
+ * @brief Class-independent utilities for HiGHS
+ */
+#ifndef LP_DATA_HIGHSSOLVE_H_
+#define LP_DATA_HIGHSSOLVE_H_
+
+#include "lp_data/HighsModelUtils.h"
+HighsStatus solveLp(HighsLpSolverObject& solver_object, const string message);
+HighsStatus solveUnconstrainedLp(HighsLpSolverObject& solver_object);
+HighsStatus solveUnconstrainedLp(const HighsOptions& options, const HighsLp& lp,
+                                 HighsModelStatus& model_status,
+                                 HighsInfo& highs_info, HighsSolution& solution,
+                                 HighsBasis& basis);
+void assessExcessiveObjectiveBoundScaling(const HighsLogOptions log_options,
+                                          const HighsModel& model,
+                                          HighsUserScaleData& user_scale_data);
+bool useIpm(const std::string& solver);
+bool usePdlp(const std::string& solver);
+bool useHipo(const HighsOptions& options,
+             const std::string& specific_solver_option, const HighsLp& lp,
+             const bool logging = false);
+#endif  // LP_DATA_HIGHSSOLVE_H_

data/ext/lpsolver-highs/highs/lp_data/HighsStatus.cpp

@@ -0,0 +1,48 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "lp_data/HighsStatus.h"
+
+#include <cassert>
+
+std::string highsStatusToString(HighsStatus status) {
+  switch (status) {
+    case HighsStatus::kOk:
+      return "OK";
+    case HighsStatus::kWarning:
+      return "Warning";
+    case HighsStatus::kError:
+      return "Error";
+    default:
+      assert(1 == 0);
+      return "Unrecognised HiGHS status";
+  }
+}
+
+HighsStatus interpretCallStatus(const HighsLogOptions log_options,
+                                const HighsStatus call_status,
+                                const HighsStatus from_return_status,
+                                const std::string& message) {
+  HighsStatus to_return_status;
+  to_return_status = worseStatus(call_status, from_return_status);
+  if (call_status != HighsStatus::kOk)
+    highsLogDev(log_options, HighsLogType::kWarning,
+                "%s return of HighsStatus::%s\n", message.c_str(),
+                highsStatusToString(call_status).c_str());
+  return to_return_status;
+}
+
+HighsStatus worseStatus(const HighsStatus status0, const HighsStatus status1) {
+  HighsStatus return_status = HighsStatus::kError;
+  if (status0 == HighsStatus::kError || status1 == HighsStatus::kError)
+    return_status = HighsStatus::kError;
+  else if (status0 == HighsStatus::kWarning || status1 == HighsStatus::kWarning)
+    return_status = HighsStatus::kWarning;
+  else
+    return_status = HighsStatus::kOk;
+  return return_status;
+}

data/ext/lpsolver-highs/highs/lp_data/HighsStatus.h

@@ -0,0 +1,29 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef LP_DATA_HIGHS_STATUS_H_
+#define LP_DATA_HIGHS_STATUS_H_
+
+#include <string>
+
+#include "io/HighsIO.h"
+
+enum class HighsStatus { kError = -1, kOk = 0, kWarning = 1 };
+
+// Return a string representation of HighsStatus.
+std::string highsStatusToString(HighsStatus status);
+
+// Return the maximum of two HighsStatus and possibly report on
+// call_status not being HighsStatus::kOk
+HighsStatus interpretCallStatus(const HighsLogOptions log_options,
+                                const HighsStatus call_status,
+                                const HighsStatus from_return_status,
+                                const std::string& message = "");
+
+// Return the maximum of two HighsStatus
+HighsStatus worseStatus(HighsStatus status0, HighsStatus status1);
+#endif

data/ext/lpsolver-highs/highs/lp_data/Iis.md

@@ -0,0 +1,113 @@
+# HiGHS irreducible infeasibility system (IIS) facility
+
+Further to documentation in https://ergo-code.github.io/HiGHS/stable/guide/advanced/
+
+Source of IIS techniques is
+
+J. W. Chinneck, "Feasibility and Infeasibility in Optimization". Algorithms and Computational Methods, Springer, New York, 2008. [DOI 10.1007/978-0-387-74932-7](https://doi.org/10.1007/978-0-387-74932-7)
+
+The IIS search is rooted in `Highs::getIisInterface()`, which first
+checks whether the `Highs::model_status_` is
+`HighsModelStatus::kOptimal` or `HighsModelStatus::kUnbounded`, in
+which case the model is feasible so no IIS exists. Otherwise, the
+trivial check (for inconsistent bounds or empty infeasible rows) -
+performed by `HighsIis::trivial()` - and infeasible rows based on row
+value bounds - performed by `HighsIis::rowValueBounds()` - are
+performed. If `Highs::options_.iis_strategy` is `kIisStrategyLight`
+then `Highs::getIisInterface()` returns.
+
+The "full" IIS calculation operates in two phases: after a set of
+mutually infeasible rows has been identified, this is reduced to an
+IIS. 
+
+## Finding a set of mutually infeasible rows
+
+The set of mutually infeasible rows can be found in two ways. For
+a well-documented example of an IIS and its calculation, see unit test
+`lp-get-iis-galenet` in `check/TestIis.cpp`.
+
+### Using a dual ray
+
+If it is known that the model is infeasible, then the simplex
+solver may have identified a dual ray. If there is a dual ray then its
+nonzeros correspond to a set of mutually infeasible constraints. If
+there is no dual ray - as might happen if the model's infeasibility
+has been identified in presolve - then the incumbent model is solved
+with `Highs::options_.presolve` = "off". Unfortunately the "ray route"
+is not robust, so currently switched off.
+
+### Using the elasticity filter
+
+Currently, the only route to finding a set of mutually infeasible rows
+is to perform an elasticity filter calculation [Chinneck
+p101-104]. This is done in `HighsIis::elasticityFilter`. This method
+is more general than is necessary for finding the set of mutually
+infeasible rows for an IIS calculation, and can be called directly
+using `Highs::feasibilityRelaxation`.
+
+The essence of the `HighsIis::elasticityFilter` is that it allows
+lower bounds, upper bounds and RHS values to be violated. There are
+penalties for doing so that can be global for each of these three
+cases, or local to each column lower bound, upper bound and row
+bound. The "elasticity LP" is constructed by adding non-negative
+elastic variables to transform the constraints from
+$$
+L <= Ax <= U;\qquad l <= x <= u
+$$
+to
+$$
+L <= Ax + e_L - e_U <= U;\qquad l <=  x + e_l - e_u <= u,
+$$
+where the elastic variables are not used if the corresponding bound is
+infinite or the local/global penalty is negative. If a bound on $x$
+can be violated, then it is removed from $x$. This is because the
+violation is modelled using a row $l <= x + e_l - e_u <= u$ containing
+at least one of $e_l$ and $e_u$, depending on whether both bounds can
+be violated. The objective of the elasticity LP is the linear function
+of the elastic variables given by the local/global penalties. Note
+that the model modifications required to achieve this formulation, are
+made by calls to methods in the `Highs` class so that the value of any
+initial basis is maintained.
+
+For the purposes of IIS calculation, since an infeasible subset of
+rows is required, only row bounds are allowed to be violated, and the
+penalty in each case is unity. Hence `HighsIis::elasticityFilter` uses
+`global_lower_penalty=-1`, `global_upper_penalty=-1` and
+`global_rhs_penalty=1`. Each finite row bound has a corresponding
+elastic variable.
+
+When the elasticity LP is solved, if all elastic variables have an
+optimal value of zero, then the original LP is feasible. Clearly the
+algorithm to find an infeasible subset of rows then
+terminates. Otherwise, the aim of the algorithm is to identify a set
+of elastic variables that, if fixed to zero, makes the elasticity LP
+infeasible. The algorithm proceeds as follows. After solving the
+elasticity LP, each elastic variable whose optimal value is positive
+is fixed at zero, and the elasticity LP is re-solved. This process
+continues until the elasticity LP is infeasible. Thus, the elastic
+variables that have been fixed at zero correspond to an infeasible
+subset of rows. Note that the algorithm must continue until the
+elasticity LP is infeasible as, for example, the initial set of
+elastic variables that have positive values may not correspond to an
+infeasible subset of rows. It is possible that these constraints can
+be satisfied, but only at the cost of a greater total violation of
+some other constraint(s) that were satisfied.
+
+## Reducing to an IIS
+
+Given an infeasible subset of rows, the method `HighsIis::getData`
+forms the LP corresponding to the subset of rows and the columns with
+nonzeros in those rows, and the row bounds corresponding to the fixed
+elastic variables. This LP is then passed to `HighsIis::compute`,
+which eliminates rows and columns from the LP until this is no longer
+possible, so the subset of rows and the columns is
+irreducible. Depending on whether the user desires a minimum number of
+rows or columns in the final IIS, it is possible to prioritise the
+removal of rows or columns according to the value of
+`Highs::options_.iis_strategy`. With the aim of finding a minimum
+number of rows in the final IIS, removal technique considers each
+finite row bound in turn. If it is relaxed and the the LP is still
+infeasible, then the bound can be removed. If this leads to both
+bounds on a row being infinite, then the row itself can be removed. A
+similar pass through the columns is performed before or after the row
+pass, depending on whether removal of columns or rows has priority.

data/ext/lpsolver-highs/highs/meson.build

@@ -0,0 +1,433 @@
+# -------------------------- Configuration
+conf_data = configuration_data()
+conf_data.set('FAST_BUILD',
+              get_option('fast_build'))
+conf_data.set('HIGHS_VERSION_MAJOR',
+              meson.project_version().split('.')[0])
+conf_data.set('HIGHS_VERSION_MINOR',
+              meson.project_version().split('.')[1])
+conf_data.set('HIGHS_VERSION_PATCH',
+              meson.project_version().split('.')[2])
+conf_data.set('ZLIB_FOUND',
+              zlib_dep.found())
+# Is the use of the following two lines the cause of the meson build
+# failure?
+conf_data.set('CUPDLP_CPU', true)
+            #  cupdlp_cpu.found())
+# 64 bit numbers
+if host_machine.cpu_family() == 'x86_64'
+    # Get user's option, if it's not provided, enable highsint64 by default on x86_64
+    highsint64_opt = get_option('highsint64')
+    conf_data.set('HIGHSINT64', highsint64_opt)
+else
+    conf_data.set('HIGHSINT64', false)
+endif
+# Date
+# today_str = 'unknown'
+# if (not meson.is_subproject())
+#     python_getdate = '''
+# import datetime
+# import os
+# import time
+
+# (ig)
+# Deprecate compilation date
+
+# build_date = datetime.datetime.utcfromtimestamp(
+#     int(os.environ.get('SOURCE_DATE_EPOCH', time.time()))
+# )
+# build_date_str = build_date.strftime('%Y-%m-%d')
+# print(build_date_str)
+#     '''
+#     # Note: this is not guaranteed to work on Windows. This should be removed
+#     #       (as proposed in gh-1735), and otherwise moved into a .py script with
+#     #       a `#!/usr/bin/env python3` shebang, and `python3 -c` dropped.
+#     today_cmd = run_command('python3', '-c',
+#                             python_getdate,
+#                             check: false)
+#     today_str = today_cmd.stdout().strip()
+# endif
+# conf_data.set_quoted('HIGHS_COMPILATION_DATE',
+#                      today_str)
+
+conf_data.set_quoted('HIGHS_COMPILATION_DATE',
+                     'deprecated')
+
+# Conditional compiler options
+_mm_pause_code = '''
+#include <immintrin.h>
+int main(){
+  _mm_pause();
+  return 0;
+}
+'''
+_have_mm_pause = cppc.compiles(_mm_pause_code,
+                              name: 'mm_pause check')
+conf_data.set('HIGHS_HAVE_MM_PAUSE',
+              _have_mm_pause)
+
+if cppc.get_id() == 'msvc'
+  _bitscan_rev_code = '''
+  #include <intrin.h>
+  #pragma intrinsic(_BitScanReverse)
+  #pragma intrinsic(_BitScanReverse64)
+  int main () {
+   unsigned long x = 5;
+   unsigned long y;
+   _BitScanReverse(&y, x);
+   _BitScanReverse64(&x, y);
+   return 0;
+   }
+   '''
+  _have_bitscan_reverse = cppc.compiles(_bitscan_rev_code,
+                                       name: 'bitscan_rev check')
+  conf_data.set('HIGHS_HAVE_BITSCAN_REVERSE',
+                _have_bitscan_reverse)
+else
+  _builtin_clz_code = '''
+  #include <cstdint>
+  int main(){
+    unsigned int x = 5;
+    unsigned long long y = __builtin_clz(x);
+    x = __builtin_clzll(y);
+    return 0;
+  }
+  '''
+  _have_builtin_clz = cppc.compiles(_builtin_clz_code,
+                                       name: 'builtin_clz check')
+  conf_data.set('HIGHS_HAVE_BUILTIN_CLZ',
+                _have_builtin_clz)
+endif
+
+interim_conf = configure_file(
+  input: 'HConfig.h.meson.in',
+  output: 'HConfig.h.meson.interim',
+  configuration: conf_data
+)
+
+highs_conf_file = vcs_tag(
+  input: interim_conf,
+  output: 'HConfig.h',
+  fallback: 'unknown',
+  replace_string: '_HIGHS_GITHASH_', # Remember to quote manually
+)
+
+_incdirs += include_directories('.')
+
+# --------------------- Libraries
+
+_cupdlp_srcs = [
+    'pdlp/cupdlp/cupdlp_cs.c',
+    'pdlp/cupdlp/cupdlp_linalg.c',
+    'pdlp/cupdlp/cupdlp_proj.c',
+    'pdlp/cupdlp/cupdlp_restart.c',
+    'pdlp/cupdlp/cupdlp_scaling.c',
+    'pdlp/cupdlp/cupdlp_solver.c',
+    'pdlp/cupdlp/cupdlp_step.c',
+    'pdlp/cupdlp/cupdlp_utils.c',
+]
+
+_basiclu_srcs = [
+    'ipm/basiclu/basiclu_factorize.c',
+    'ipm/basiclu/basiclu_get_factors.c',
+    'ipm/basiclu/basiclu_initialize.c',
+    'ipm/basiclu/basiclu_object.c',
+    'ipm/basiclu/basiclu_solve_dense.c',
+    'ipm/basiclu/basiclu_solve_for_update.c',
+    'ipm/basiclu/basiclu_solve_sparse.c',
+    'ipm/basiclu/basiclu_update.c',
+    'ipm/basiclu/lu_build_factors.c',
+    'ipm/basiclu/lu_condest.c',
+    'ipm/basiclu/lu_dfs.c',
+    'ipm/basiclu/lu_factorize_bump.c',
+    'ipm/basiclu/lu_file.c',
+    'ipm/basiclu/lu_garbage_perm.c',
+    'ipm/basiclu/lu_initialize.c',
+    'ipm/basiclu/lu_internal.c',
+    'ipm/basiclu/lu_markowitz.c',
+    'ipm/basiclu/lu_matrix_norm.c',
+    'ipm/basiclu/lu_pivot.c',
+    'ipm/basiclu/lu_residual_test.c',
+    'ipm/basiclu/lu_setup_bump.c',
+    'ipm/basiclu/lu_singletons.c',
+    'ipm/basiclu/lu_solve_dense.c',
+    'ipm/basiclu/lu_solve_for_update.c',
+    'ipm/basiclu/lu_solve_sparse.c',
+    'ipm/basiclu/lu_solve_symbolic.c',
+    'ipm/basiclu/lu_solve_triangular.c',
+    'ipm/basiclu/lu_update.c',
+]
+
+_ipx_srcs = [
+    'ipm/ipx/basiclu_kernel.cc',
+    'ipm/ipx/basiclu_wrapper.cc',
+    'ipm/ipx/basis.cc',
+    'ipm/ipx/conjugate_residuals.cc',
+    'ipm/ipx/control.cc',
+    'ipm/ipx/crossover.cc',
+    'ipm/ipx/diagonal_precond.cc',
+    'ipm/ipx/forrest_tomlin.cc',
+    'ipm/ipx/guess_basis.cc',
+    'ipm/ipx/indexed_vector.cc',
+    'ipm/ipx/info.cc',
+    'ipm/ipx/ipm.cc',
+    'ipm/ipx/ipx_c.cc',
+    'ipm/ipx/iterate.cc',
+    'ipm/ipx/kkt_solver.cc',
+    'ipm/ipx/kkt_solver_basis.cc',
+    'ipm/ipx/kkt_solver_diag.cc',
+    'ipm/ipx/linear_operator.cc',
+    'ipm/ipx/lp_solver.cc',
+    'ipm/ipx/lu_factorization.cc',
+    'ipm/ipx/lu_update.cc',
+    'ipm/ipx/maxvolume.cc',
+    'ipm/ipx/model.cc',
+    'ipm/ipx/normal_matrix.cc',
+    'ipm/ipx/sparse_matrix.cc',
+    'ipm/ipx/sparse_utils.cc',
+    'ipm/ipx/splitted_normal_matrix.cc',
+    'ipm/ipx/starting_basis.cc',
+    'ipm/ipx/symbolic_invert.cc',
+    'ipm/ipx/timer.cc',
+    'ipm/ipx/utils.cc',
+]
+
+_srcs = [
+    'io/filereaderlp/reader.cpp',
+    'interfaces/highs_c_api.cpp',
+    'io/Filereader.cpp',
+    'io/FilereaderLp.cpp',
+    'io/FilereaderMps.cpp',
+    'io/HMPSIO.cpp',
+    'io/HMpsFF.cpp',
+    'io/HighsIO.cpp',
+    'io/LoadOptions.cpp',
+    'ipm/IpxWrapper.cpp',
+    'lp_data/Highs.cpp',
+    'lp_data/HighsCallback.cpp',
+    'lp_data/HighsDebug.cpp',
+    'lp_data/HighsIis.cpp',
+    'lp_data/HighsDeprecated.cpp',
+    'lp_data/HighsInfo.cpp',
+    'lp_data/HighsInfoDebug.cpp',
+    'lp_data/HighsInterface.cpp',
+    'lp_data/HighsLp.cpp',
+    'lp_data/HighsLpUtils.cpp',
+    'lp_data/HighsModelUtils.cpp',
+    'lp_data/HighsOptions.cpp',
+    'lp_data/HighsRanging.cpp',
+    'lp_data/HighsSolution.cpp',
+    'lp_data/HighsSolutionDebug.cpp',
+    'lp_data/HighsSolve.cpp',
+    'lp_data/HighsStatus.cpp',
+    'mip/HighsCliqueTable.cpp',
+    'mip/HighsConflictPool.cpp',
+    'mip/HighsCutGeneration.cpp',
+    'mip/HighsCutPool.cpp',
+    'mip/HighsDebugSol.cpp',
+    'mip/HighsDomain.cpp',
+    'mip/HighsDynamicRowMatrix.cpp',
+    'mip/HighsFeasibilityJump.cpp',
+    'mip/HighsGFkSolve.cpp',
+    'mip/HighsImplications.cpp',
+    'mip/HighsLpAggregator.cpp',
+    'mip/HighsLpRelaxation.cpp',
+    'mip/HighsMipAnalysis.cpp',
+    'mip/HighsMipSolver.cpp',
+    'mip/HighsMipSolverData.cpp',
+    'mip/HighsModkSeparator.cpp',
+    'mip/HighsNodeQueue.cpp',
+    'mip/HighsObjectiveFunction.cpp',
+    'mip/HighsPathSeparator.cpp',
+    'mip/HighsPrimalHeuristics.cpp',
+    'mip/HighsPseudocost.cpp',
+    'mip/HighsRedcostFixing.cpp',
+    'mip/HighsSearch.cpp',
+    'mip/HighsSeparation.cpp',
+    'mip/HighsSeparator.cpp',
+    'mip/HighsTableauSeparator.cpp',
+    'mip/HighsTransformedLp.cpp',
+    'model/HighsHessian.cpp',
+    'model/HighsHessianUtils.cpp',
+    'model/HighsModel.cpp',
+    'parallel/HighsTaskExecutor.cpp',
+    'pdlp/CupdlpWrapper.cpp',
+    'pdlp/HiPdlpWrapper.cpp',
+    'pdlp/hipdlp/linalg.cc',
+    'pdlp/hipdlp/logger.cc',
+    'pdlp/hipdlp/pdhg.cc',
+    'pdlp/hipdlp/restart.cc',
+    'pdlp/hipdlp/scaling.cc',
+    'presolve/HPresolve.cpp',
+    'presolve/HPresolveAnalysis.cpp',
+    'presolve/HighsPostsolveStack.cpp',
+    'presolve/HighsSymmetry.cpp',
+    'presolve/ICrash.cpp',
+    'presolve/ICrashUtil.cpp',
+    'presolve/ICrashX.cpp',
+    'presolve/PresolveComponent.cpp',
+    'qpsolver/a_asm.cpp',
+    'qpsolver/a_quass.cpp',
+    'qpsolver/basis.cpp',
+    'qpsolver/perturbation.cpp',
+    'qpsolver/quass.cpp',
+    'qpsolver/ratiotest.cpp',
+    'qpsolver/scaling.cpp',
+    'simplex/HEkk.cpp',
+    'simplex/HEkkControl.cpp',
+    'simplex/HEkkDebug.cpp',
+    'simplex/HEkkDual.cpp',
+    'simplex/HEkkDualMulti.cpp',
+    'simplex/HEkkDualRHS.cpp',
+    'simplex/HEkkDualRow.cpp',
+    'simplex/HEkkInterface.cpp',
+    'simplex/HEkkPrimal.cpp',
+    'simplex/HSimplex.cpp',
+    'simplex/HSimplexDebug.cpp',
+    'simplex/HSimplexNla.cpp',
+    'simplex/HSimplexNlaDebug.cpp',
+    'simplex/HSimplexNlaFreeze.cpp',
+    'simplex/HSimplexNlaProductForm.cpp',
+    'simplex/HSimplexReport.cpp',
+    'simplex/HighsSimplexAnalysis.cpp',
+    'test_kkt/DevKkt.cpp',
+    'test_kkt/KktCh2.cpp',
+    'util/HFactor.cpp',
+    'util/HFactorDebug.cpp',
+    'util/HFactorExtend.cpp',
+    'util/HFactorRefactor.cpp',
+    'util/HFactorUtils.cpp',
+    'util/HSet.cpp',
+    'util/HVectorBase.cpp',
+    'util/HighsHash.cpp',
+    'util/HighsLinearSumBounds.cpp',
+    'util/HighsMatrixPic.cpp',
+    'util/HighsMatrixUtils.cpp',
+    'util/HighsSort.cpp',
+    'util/HighsSparseMatrix.cpp',
+    'util/HighsUtils.cpp',
+    'util/stringutil.cpp',
+]
+
+highslib_srcs = [
+  files(_srcs),
+  files(_cupdlp_srcs),
+  files(_basiclu_srcs),
+  files(_ipx_srcs),
+]
+
+
+symbol_visibility = 'default'
+if get_option('default_library') == 'static'
+  # Ensure that if we link a static library into a shared library,
+  # private symbols don't get re-exported.
+  symbol_visibility = 'inlineshidden'
+endif
+
+do_install = get_option('do_install')
+
+if not get_option('with_pybind11')
+highslib = library('highs',
+                   highslib_srcs + highs_conf_file,
+                   dependencies: _deps,
+                   cpp_args: _highs_cpp_suppressions + _args,
+                   c_args: _highs_c_suppressions + _args,
+                   include_directories: _incdirs,
+                   gnu_symbol_visibility: symbol_visibility,
+                   pic: true,
+                   install: do_install)
+
+highs_dep = declare_dependency(link_with: highslib,
+                               dependencies: _deps,
+                               include_directories: _incdirs,
+                               )
+endif
+
+# --------------- Interfaces
+
+# Fortran
+if get_option('with_fortran')
+  add_languages('fortran', required: true)
+  _fsrcs = [
+    'interfaces/highs_fortran_api.f90'
+  ]
+  library('FortranHighs',
+          _fsrcs,
+          dependencies: _deps,
+          cpp_args: _args,
+          link_with: highslib,
+          include_directories: _incdirs,
+          pic: true,
+          install: do_install)
+endif
+
+# C#
+if get_option('with_csharp')
+  add_languages('cs', required: true)
+  _cs_srcs = [
+    'interfaces/highs_csharp_api.cs'
+  ]
+  library('HighsCsharp',
+          _cs_srcs,
+          dependencies: _deps,
+          cpp_args: _args,
+          link_with: highslib,
+          include_directories: _incdirs,
+          pic: true,
+          install: do_install)
+endif
+
+highspy_cpp = files([
+  'highs_bindings.cpp'
+])
+
+if get_option('with_pybind11')
+  py = import('python').find_installation(pure: false)
+
+  highslib = library('highs',
+                     highslib_srcs + highs_conf_file,
+                     dependencies: _deps,
+                     cpp_args: _highs_cpp_suppressions + _args,
+                     c_args: _highs_c_suppressions + _args,
+                     include_directories: _incdirs,
+                     gnu_symbol_visibility: symbol_visibility,
+                     pic: true,
+                     install: do_install,
+                     install_dir: py.get_install_dir() / 'highspy')
+
+  highs_dep = declare_dependency(link_with: highslib,
+                                 dependencies: _deps,
+                                 include_directories: _incdirs,
+                                )
+  _deps += highs_dep
+  pyb11_dep = [
+    # py_dep is auto-added for Python >= 3.9, so it can be dropped here when
+    # that is the minimum supported Python version
+    py.dependency(),
+    dependency('pybind11')
+  ]
+  _deps += pyb11_dep
+
+  highspy_cpp = files([
+    'highs_bindings.cpp'
+  ])
+
+  py.extension_module(
+    '_core',
+    sources : highspy_cpp,
+    dependencies: [pyb11_dep, highs_dep],
+    cpp_args: _args,
+    install: do_install,
+    subdir: 'highspy',
+    include_directories: _incdirs,
+  )
+
+ highs_py_srcs = files(
+      'highspy/__init__.py',
+      'highspy/highs.py',)
+
+  py.install_sources(highs_py_srcs,
+    pure: false,
+    subdir: 'highspy'
+  )
+endif