lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/docs/HiGHS_CopyrightHeaderUpdateAll

@@ -0,0 +1,32 @@
+./HiGHS_CopyrightHeader.pl ../highs/Highs.h
+./HiGHS_CopyrightHeader.pl ../highs/ipm/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/ipm/*.h
+./HiGHS_CopyrightHeader.pl ../highs/interfaces/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/interfaces/*.h
+./HiGHS_CopyrightHeader.pl ../highs/interfaces/*.hpp
+./HiGHS_CopyrightHeader.pl ../highs/io/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/io/*.h
+./HiGHS_CopyrightHeader.pl ../highs/lp_data/*.h
+./HiGHS_CopyrightHeader.pl ../highs/lp_data/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/mip/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/mip/*.h
+./HiGHS_CopyrightHeader.pl ../highs/mip/*.hh
+./HiGHS_CopyrightHeader.pl ../highs/model/*.h
+./HiGHS_CopyrightHeader.pl ../highs/model/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/parallel/*.h
+./HiGHS_CopyrightHeader.pl ../highs/parallel/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/pdlp/*.h
+./HiGHS_CopyrightHeader.pl ../highs/pdlp/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/pdlp/hipdlp/*.hpp
+./HiGHS_CopyrightHeader.pl ../highs/pdlp/hipdlp/*.cc
+./HiGHS_CopyrightHeader.pl ../highs/presolve/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/presolve/*.h
+./HiGHS_CopyrightHeader.pl ../highs/qpsolver/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/qpsolver/*.hpp
+./HiGHS_CopyrightHeader.pl ../highs/simplex/*.h
+./HiGHS_CopyrightHeader.pl ../highs/simplex/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/test_kkt/*.h
+./HiGHS_CopyrightHeader.pl ../highs/test_kkt/*.cpp
+./HiGHS_CopyrightHeader.pl ../highs/util/*.h
+./HiGHS_CopyrightHeader.pl ../highs/util/*.cpp
+./HiGHS_CopyrightHeader.pl ../app/RunHighs.cpp

data/ext/lpsolver-highs/docs/Project.toml

@@ -0,0 +1,7 @@
+[deps]
+Clang = "40e3b903-d033-50b4-a0cc-940c62c95e31"
+Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+
+[compat]
+#Clang = "0.14, 0.17, 0.18"
+Documenter = "0.27"

data/ext/lpsolver-highs/docs/README.md

@@ -0,0 +1,27 @@
+# Documentation
+
+This directory contains the source files for the [documentation](https://ergo-code.github.io/HiGHS).
+
+## Editing the documentation
+
+To edit the documentation, checkout a branch and edit the Markdown files in the
+`src` directory.
+
+## Building the documentation
+
+To build locally, [install Julia](https://julialang.org/downloads/), then (from the `docs` directory) run:
+
+``` bash
+$ julia make.jl
+```
+
+The first time you run this command, Julia will download and install the
+necessary packages. This may take a couple of minutes.
+
+The website is generated in the `build/` folder. To check it out, load
+`build/index.html` in your browser.
+
+## Deploying the documentation
+
+The documentation is automatically built and deployed by a GitHub action. You
+should not check the `build/` directory into git.

data/ext/lpsolver-highs/docs/c_api_gen/HConfig.h

@@ -0,0 +1 @@
+// A dummy file to fix a warning when Julia parses the C API.

data/ext/lpsolver-highs/docs/c_api_gen/build.jl

@@ -0,0 +1,48 @@
+#=* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+*                                                                       *
+*    This file is part of the HiGHS linear optimization suite           *
+*                                                                       *
+*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    *
+*    Leona Gottwald and Michael Feldmeier                               *
+*    Available as open-source under the MIT License                     *
+*                                                                       *
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *=#
+
+import Clang: Generators
+
+highs_src = joinpath(dirname(dirname(@__DIR__)), "highs")
+c_api = joinpath(highs_src, "interfaces", "highs_c_api.h")
+libhighs_filename = joinpath(@__DIR__, "libhighs.jl")
+
+Generators.build!(
+    Generators.create_context(
+        [c_api, joinpath(highs_src, "util", "HighsInt.h")],
+        [Generators.get_default_args(); "-I$highs_src"; "-I$(@__DIR__)"],
+        Dict{String,Any}(
+            "general" => Dict{String,Any}(
+                "output_file_path" => libhighs_filename,
+                "library_name" => "libhighs",
+                "print_using_CEnum" => false,
+                "extract_c_comment_style" => "doxygen",
+            )
+        ),
+    ),
+)
+
+write(
+    libhighs_filename,
+    replace(
+        read(libhighs_filename, String),
+        "[`HighsInt`](@ref)" => "`HighsInt`",
+    ),
+)
+
+open(libhighs_filename, "a") do io
+    for line in readlines(c_api)
+        m = match(r"const HighsInt kHighs([a-zA-Z]+) = (-?[0-9]+);", line)
+        if m === nothing
+            continue
+        end
+        println(io, "const kHighs$(m[1]) = HighsInt($(m[2]))")
+    end
+end

data/ext/lpsolver-highs/docs/make.jl

@@ -0,0 +1,115 @@
+#=* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+*                                                                       *
+*    This file is part of the HiGHS linear optimization suite           *
+*                                                                       *
+*    Available as open-source under the MIT License                     *
+*                                                                       *
+* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *=#
+
+import Pkg
+Pkg.activate(@__DIR__)
+Pkg.instantiate()
+
+import Documenter
+
+# ==============================================================================
+#  Parse and build docstrings from the C API
+# ==============================================================================
+
+const libhighs = ""
+include(joinpath(@__DIR__, "c_api_gen", "build.jl"))
+include(joinpath(@__DIR__, "c_api_gen", "libhighs.jl"))
+
+# ==============================================================================
+#  Make the documentation
+# ==============================================================================
+
+Documenter.makedocs(
+    sitename = "HiGHS Documentation",
+    authors = "Julian Hall and Ivet Galabova",
+    format = Documenter.HTML(
+        # Use clean URLs, unless built as a "local" build
+        # prettyurls = !("local" in ARGS),
+        prettyurls = get(ENV, "CI", nothing) == "true",
+        highlights = ["yaml"],
+    ),
+    strict = !("strict=false" in ARGS),
+    doctest = ("doctest=only" in ARGS) ? :only : true,
+    repo = "https://github.com/ERGO-Code/HiGHS/tree/latest{path}",
+    linkcheck = false,
+    linkcheck_ignore = [
+        "https://crates.io/crates/highs",
+        "https://crates.io/crates/good_lp",
+        "https://link.springer.com/article/10.1007/s12532-017-0130-5",
+	"https://link.springer.com/article/10.1007/s12532-020-00181-8",
+	"https://github.com/ERGO-Code/HiGHS/blob/master/highs/Highs.h"
+    ],
+    pages = [
+        "About" => "index.md",
+        "installation.md",
+        "Executable" => "executable.md",
+        "Guide" => Any[
+            "guide/index.md",
+            "guide/basic.md",
+            "guide/further.md",
+            "guide/advanced.md",
+            "guide/gpu.md",
+            "guide/kkt.md",
+            "guide/numerics.md"
+        ],
+	"Data structures" => Any[
+	    "structures/index.md",
+	    "structures/enums.md",
+	    "Classes" => Any[
+                "structures/classes/index.md",
+                "structures/classes/HighsSparseMatrix.md",
+                "structures/classes/HighsLp.md",
+                "structures/classes/HighsHessian.md",
+                "structures/classes/HighsModel.md",
+                "structures/classes/HighsIis.md"
+            ],
+	    "Structures" => Any[
+                "structures/structs/index.md",
+                "structures/structs/HighsSolution.md",
+                "structures/structs/HighsBasis.md",
+                "structures/structs/HighsInfo.md",
+                "structures/structs/HighsLinearObjective.md"
+            ],
+	],
+        "Callbacks" => "callbacks.md",
+        "Interfaces" => Any[
+            "C++" => Any[
+                "interfaces/cpp/index.md",
+                "The HiGHS library" => "interfaces/cpp/library.md",
+                "Examples" => "interfaces/cpp/examples.md",
+            ],
+            "C" => "interfaces/c_api.md",
+            "Fortran" => "interfaces/fortran.md",
+            "Python" => Any[
+                "interfaces/python/index.md",
+                "interfaces/python/example-py.md",
+                "interfaces/python/model-py.md",
+            ],
+            "CSharp" => "interfaces/csharp.md",
+            "Julia" => "interfaces/julia/index.md",
+            "Other" => "interfaces/other.md",
+        ],
+        "Options" => Any[
+            "options/intro.md",
+            "options/definitions.md"
+        ],
+        "Parallel" => "parallel.md",
+        "Solvers" => "solvers.md",
+        "Terminology" => "terminology.md",
+    ],
+)
+
+# ==============================================================================
+#  Deploy everything in `build`
+# ==============================================================================
+
+Documenter.deploydocs(;
+    repo = "github.com/ERGO-Code/HiGHS.git",
+    push_preview = true,
+    devbranch = "latest",
+)

data/ext/lpsolver-highs/docs/src/callbacks.md

@@ -0,0 +1,171 @@
+# Callbacks
+
+The HiGHS callback allows user actions to be performed within HiGHS. There is
+one generic callback method that can be defined by a user, with specific
+callback scenarios communicated to the user via a parameter. Particular
+callbacks must be activated (and can be deactivated) as described below. The
+user callback can be given any name and, below, is called `userCallback`. Its
+definition is
+
+```cpp
+void userCallback(const int callback_type,
+                  const char* message,
+                  const HighsCallbackDataOut* data_out,
+                  HighsCallbackDataIn* data_in,
+                  void* user_callback_data);
+```
+
+where
+
+* `callback_type` is the type of callback
+* `message` is a line of text associated with the callback.
+* `data_out` communicates data from HiGHS to the user
+* `data_in` communicates data from the user to HiGHS
+* `user_callback_data` allows the user to pass data to the callback
+
+The logging callback type is a cast of the relevant member of the C++ enum
+`HighsCallbackType`, and is available in C as a constant.
+
+The user's callback method is communicated to HiGHS via the method that in the HiGHS C++ class is
+```cpp
+HighsStatus setCallback(void (*userCallback)(const int, const char*, const HighsCallbackDataOut*,
+                        HighsCallbackDataIn*, void*), void* user_callback_data);
+```
+and, in the HiGHS C API is
+```cpp
+HighsInt Highs_setCallback(
+    void* highs,
+    void (*userCallback)(const int, const char*,
+                         const struct HighsCallbackDataOut*,
+                         struct HighsCallbackDataIn*, void*),
+    void* user_callback_data)
+```
+The current callback scenarios are set out below, and the particular callback is activated in C++ by calling
+
+```cpp
+HighsStatus startCallback(const int callback_type);
+```
+and, in C, by calling
+```cpp
+HighsInt Highs_startCallback(void* highs, const int callback_type);
+```
+, and de-activated in C++ by calling
+```cpp
+HighsStatus stopCallback(const int callback_type);
+```
+and, in C, by calling
+```cpp
+HighsInt Highs_stopCallback(void* highs, const int callback_type);
+```
+
+### User interrupt
+
+For the non-logging callbacks below, if the `user_interrupt` member of the
+`HighsCallbackDataIn` struct is set to a nonzero value, then the
+corresponding solver will be interrupted, and HiGHS will return to the
+user.
+
+### Logging callback
+
+The logging callback type is a cast of `kCallbackLogging` in the C++
+enum `HighsCallbackType` and, in C, is the constant
+`kHighsCallbackLogging`. The logging type is a cast of the particular
+member of the enum class 'HighsLogType', and is available as a
+constant in C. It is passed as the member `log_type` in the
+`HighsCallbackDataOut` struct, and the message is passed as the `const
+char*` parameter.
+
+### Simplex interrupt callback
+
+The simplex interrupt is called once every simplex iteration, and its
+callback type is a cast of `kCallbackSimplexInterrupt` in the C++ enum
+`HighsCallbackType`, and the `kHighsCallbackSimplexInterrupt` constant
+in C. The simplex iteration count is passed as the
+`simplex_iteration_count` member of the `HighsCallbackDataOut` struct.
+
+### IPM interrupt callback
+
+The IPM interrupt is called once every interior point iteration, and
+its callback type is a cast of `kCallbackIpmInterrupt` in the C++ enum
+`HighsCallbackType`, and the `kHighsCallbackIpmInterrupt` constant in
+C. The IPM iteration count is passed as the `ipm_iteration_count`
+member of the `HighsCallbackDataOut` struct.
+
+### MIP improving solution callback
+
+The MIP improving solution is called whenever the MIP solver
+identifies an improving integer feasible solution, and its callback
+type is a cast of `kCallbackMipImprovingSolution` in the C++ enum
+`HighsCallbackType`, and the `kHighsCallbackMipImprovingSolution`
+constant in C. A pointer to the improving solution is passed as the
+`objective_function_value` and `mip_solution` members of the
+`HighsCallbackDataOut` struct.
+
+### MIP solution callback
+
+The MIP solution is called whenever the MIP solver
+identifies an integer feasible solution, and its callback
+type is a cast of `kCallbackMipSolution` in the C++ enum
+`HighsCallbackType`, and the `kHighsCallbackMipSolution`
+constant in C. A pointer to the solution is passed as the
+`objective_function_value` and `mip_solution` members of the
+`HighsCallbackDataOut` struct.
+
+### MIP logging callback
+
+The MIP logging callback is called once every time MIP logging takes
+place, and its callback type is a cast of `kCallbackMipLogging` in the
+C++ enum `HighsCallbackType`, and `kHighsCallbackMipLogging` in C.
+
+### MIP interrupt callback
+
+The MIP interrupt callback is called when the MIP solver checks
+whether computation limits (such as time, node, leaves, improving
+solutions, and target objective) have been reached, and its callback
+type is a cast of `kCallbackMipInterrupt` in the C++ enum
+`HighsCallbackType`, and the `kHighsCallbackMipInterrupt` constant in
+C. The simplex iteration count is passed as the
+`simplex_iteration_count` member of the `HighsCallbackDataOut` struct.
+
+### MIP user solution callback
+
+The MIP user solution callback is called after setting up the MIP
+solver, at five points when exploring the root node, and before each
+dive in the branch-and-bound tree search. The origin of the call is
+given by the value of the `external_solution_query_origin` member of
+the `HighsCallbackDataOut` struct. The aim is to allow potential
+feasible primal solutions generated externally to be passed to the
+HiGHS MIP solver. Note that by introducing data to the HiGHS MIP
+solver at the user's discretion, its behaviour will generally be
+non-deterministic.
+
+### MIP cut pool callback
+
+The MIP cut pool callback is called after generating cuts at the root
+node, and its callback type is a cast of `kCallbackMipGetCutPool` in
+the C++ enum `HighsCallbackType`, and the
+`kHighsCallbackMipGetCutPool` constant in C. The data supplied
+consists of the compressed sparse column representation of the cutpool
+constraint matrix, and the corresponding lower and upper bounds.
+
+## Callback data output
+
+The `HighsCallbackDataOut` struct supplies data to the user that is
+relevant to the particular callback. The general data are
+
+* `log_type`: An integer cast of the `HighsLogType` value, indicating the severity of the logging message--relevant to the logging callback.
+* `running_time`: The excution time of HiGHS--relevant to the interrupt callbacks.
+* `simplex_iteration_count`: The number of simplex iterations performed--relevant to the simplex interrupt callback.
+* `ipm_iteration_count`: The number of IPM iterations performed--relevant to the IPM interrupt callback.
+* `pdlp_iteration_count`: The number of PDLP iterations performed--relevant to the PDLP interrupt callback.
+
+### MIP callback data
+
+For each of the MIP callbacks, the following `HighsCallbackDataOut`
+struct members will also have their value set
+
+* `objective_function_value`: the objective function value of the best integer feasible solution found
+* `mip_node_count`: the number of MIP nodes explored to date
+* `mip_primal_bound`: the primal bound
+* `mip_dual_bound`: the dual bound
+* `mip_gap`: the (relative) difference between the primal and dual bounds

data/ext/lpsolver-highs/docs/src/executable.md

@@ -0,0 +1,88 @@
+# [Executable](@id executable)
+
+HiGHS can run as a stand-alone program with a command-line
+interface. It solves an optimization problem provided by either an
+[MPS](https://docs.gurobi.com/projects/optimizer/en/current/reference/fileformats/modelformats.html#mps-format)
+file, or
+[LP](https://docs.gurobi.com/projects/optimizer/en/current/reference/fileformats/modelformats.html#lp-format)
+file. Note that HiGHS cannot read the [lpsolve LP file
+format](https://lpsolve.sourceforge.net/5.5/lp-format.htm).
+
+### Running the executable
+
+For convenience, the executable is assumed to be `bin/highs`.
+The model given by the MPS file `model.mps` is solved by the command:
+
+```shell
+$ bin/highs model.mps
+```
+
+If the model file is not in the folder from which the command was issued, then a
+path name can be given.
+
+### Command line options
+
+HiGHS is controlled by [option](@ref options-intro) values. When it is
+run from the command line, some fundamental option values may be
+specified directly. Many more may be specified via a file containing
+HiGHS options settings. Formally, the usage is:
+
+```shell
+$ bin/highs --help
+usage:
+      ./bin/highs [options] [file]
+
+options:
+      --model_file file          File of model to solve.
+      --options_file file        File containing HiGHS options.
+      --read_solution_file file  File of solution to read.
+      --read_basis_file text     File of initial basis to read. 
+      --write_model_file text    File for writing out model.
+      --solution_file text       File for writing out solution.
+      --write_basis_file text    File for writing out final basis.
+      --presolve text            Set presolve option to:
+                                   "choose" * default 
+                                   "on"
+                                   "off"
+      --solver text              Set solver option to: 
+                                   "choose" * default 
+                                   "simplex"
+                                   "ipm" 
+      --parallel text            Set parallel option to: 
+                                   "choose" * default 
+                                   "on" 
+                                   "off" 
+      --run_crossover text       Set run_crossover option to: 
+                                   "choose" 
+                                   "on" * default 
+                                   "off" 
+      --time_limit float         Run time limit (seconds - double).
+      --random_seed int          Seed to initialize random number 
+                                 generation.
+      --ranging text             Compute cost, bound, RHS and basic 
+                                 solution ranging:
+                                   "on" 
+                                   "off" * default 
+  -v, --version                  Print version.
+  -h, --help                     Print help.
+```
+
+The [list of options](@ref option-definitions) section gives a full
+list of options, and their default values. In a file containing HiGHS
+options they are specified as `name = value`, with one per line, and
+any line beginning with `#` treated as a comment. For example, the
+primal-dual hybrid gradient method for LP (PDLP) is used with all
+feasibility and optimality tolerances set to `1e-4` if HiGHS reads the
+following in its options file.
+```shell
+solver = pdlp
+kkt_tolerance = 1e-4
+```
+
+### Return code values
+
+Consistent with the callable methods in HiGHS, there are three possible return codes
+
+ * -1: An error has occurred in HiGHS
+ * 0: HiGHS has run successfully
+ * 1: HiGHS has recovered from an unusual event, or has terminated due to reaching a time or iteration limit

data/ext/lpsolver-highs/docs/src/guide/advanced.md

@@ -0,0 +1,66 @@
+# [Advanced features](@id guide-advanced)
+
+
+## Simplex tableau data
+
+HiGHS has a suite of methods for operations with the invertible
+representation of the current basis matrix ``B``. To use
+these requires knowledge of the corresponding (ordered) basic
+variables. This is obtained using the
+method
+`getBasicVariables`
+, with non-negative values being
+columns and negative values corresponding to row indices plus one [so
+-1 indicates row 0]. Methods
+`getBasisInverseRow`
+and
+`getBasisInverseCol`
+yield a specific row or column
+of ``B^{-1}``. Methods
+`getBasisSolve`
+and
+`getBasisTransposeSolve`
+yield the solution
+of ``Bx=b`` and ``B^{T}x=b`` respectively. Finally, the
+methods
+`getReducedRow`
+and
+`getReducedColumn`
+yield a specific row or column of ``B^{-1}A``. In all cases,
+HiGHS can return the number and indices of the nonzeros in the result.
+
+## [Irreducible infeasibility system (IIS) detection](@id highs-iis)
+
+An Irreducible infeasibility system (IIS) consists of a set of
+variables and a set of constraints in a model, together with
+variable/constraint bound information, that cannot be satisfied (so is
+infeasible). It is irreducible in that if any constraint or variable
+bound is removed, then the system can be satisfied (so is feasible).
+
+HiGHS has an IIS facility that is under development. Currently it can
+only be used for LPs. The full IIS calculation is expensive, since it
+requires the solution of multiple LPs. Although there is a prototype
+implementation, it is not as robust or efficient as it will
+be. Otherwise, there is a simple, cheap test that looks for
+infeasibility due to incompatible variable or constraint bounds, or
+constraint bounds that cannot be satisfied given the range of values
+on the constraint activity implied by bounds on variables.
+
+The choice of IIS strategy is defined by the [iis_strategy](@ref option-iis-strategy) option. This a bit map
+
+- 0 => "light strategy", which is always performed when Highs::getIis is called
+- 1 => From dual ray, which is currently unavailable
+- 2 => From the whole LP (solving an elasticity LP repeatedly (fixing positive elastic variables at zero) until no more elastic variables are positive, and using the fixed elastic variables to determine a set of infeasible rows, for which there is a corresponding set of columns with nonzeros in those rows that form an infeasibility set (IS)
+- 4 => Attempt to reduce the IS to an ISS
+- 8 => Prioritize low numbers of columns (rather than low numbers of rows) when reducing the IS
+
+Hence, by just setting the 2-bit, an IS is formed reliably, and at no great expense (for an LP)
+
+### IIS-related methods in the `Highs` class
+
+- `const HighsLp& getIisLp()`: Return a const reference to the internal IIS LP instance
+- `HighsStatus getIis(HighsIis& iis)`: Try to find an IIS for the incumbent model. Gets the internal [HighsIis](@ref) instance, returning `HighsStatus::kError` if the calculation failed. Note that if the incumbent model is found to be feasible, this is a "success", and `HighsStatus::kOk` is returned.
+- ` HighsStatus writeIisModel(const std::string& filename = "")`: Write out the internal IIS LP instance to a file.
+
+
+