Skip to content

Update solver documentation - for v1.14 #2787

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
jajhall wants to merge 9 commits into
base: latest
Choose a base branch
from
+118 −63
Draft

Update solver documentation - for v1.14 #2787

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
9 commits
Select commit Hold shift + click to select a range
5346834
Started updating docs/src/solvers.md
Jan 28, 2026
ab6fc85
Merged @filicat's mods
jajhall Jan 28, 2026
a3bbb6b
WIP
jajhall Jan 29, 2026
9ffa3b2
Updated solvers.md and parallel.md
Jan 29, 2026
fa01068
Added section to parallel.md in order to close #2752
Jan 29, 2026
6a87ae8
Updated solvers.md
jajhall Jan 30, 2026
72c178b
Commented out call to writeLpMatrixPicToFile
jajhall Jan 30, 2026
facd1d7
Tried to fix error in solvers.md, but cannot build locally
jajhall Jan 30, 2026
f81fddc
Qualified qp_iteration_limit, qp_nullspace_limit and qp_regularizatio…
Feb 5, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
18 changes: 9 additions & 9 deletions docs/src/options/definitions.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@
- Default: "choose"

## [solver](@id option-solver)
- LP solver option: "choose", "simplex", "ipm", "ipx", "hipo" or "pdlp"
- LP solver option: "choose", "simplex", "ipm", "ipx", "hipo", "pdlp", "qpasm"
- Type: string
- Default: "choose"

Expand Down Expand Up @@ -407,12 +407,12 @@
- Range: [0, inf]
- Default: 5

## mip\_lp\_solver
## [mip\_lp\_solver](@id option-mip-lp-solver)
- MIP LP solver: "choose", "simplex", "ipm", "ipx" or "hipo"
- Type: string
- Default: "choose"

## mip\_ipm\_solver
## [mip\_ipm\_solver](@id option-mip-ipm-solver)
- MIP IPM solver: "choose", "ipx" or "hipo"
- Type: string
- Default: "choose"
Expand Down Expand Up @@ -462,9 +462,9 @@
- Default: 2147483647

## pdlp\_e\_restart\_method
- Restart mode for PDLP solver: 0 => none; 1 => GPU (default); 2 => CPU
- Restart mode for PDLP solver: 0 => none; 1 => GPU (default); 2 => CPU; 2 => Halpern
- Type: integer
- Range: {0, 2}
- Range: {0, 3}
- Default: 1

## [pdlp\_optimality\_tolerance](@id option-pdlp-optimality-tolerance)
Expand All @@ -474,19 +474,19 @@
- Default: 1e-07

## qp\_iteration\_limit
- Iteration limit for QP solver
- Iteration limit for the active set QP solver
- Type: integer
- Range: {0, 2147483647}
- Default: 2147483647

## qp\_nullspace\_limit
- Nullspace limit for QP solver
## [qp\_nullspace\_limit](@id option-qp-nullspace-limit)
- Nullspace limit for the active set QP solver
- Type: integer
- Range: {0, 2147483647}
- Default: 4000

## qp\_regularization\_value
- Regularization value added to the Hessian
- Regularization value added to the Hessian in the active set QP solver
- Type: double
- Range: [0, inf]
- Default: 1e-07
Expand Down
14 changes: 8 additions & 6 deletions docs/src/parallel.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
# Parallelism
# [Parallelism](@id parallelism)

## Generally

Expand Down Expand Up @@ -63,22 +63,24 @@ If the [parallel](@ref) option is set "choose", the solver selects which
level to use based on a heuristic. When the [parallel](@ref) option is set
"choose" or "off", the value of the hipo\_parallel\_type option is ignored.


## Future plans

The MIP solver has been written with parallel tree search in mind. Some
work has started (Feb 2025), and it is hoped that a prototype solver
will be available during 2025.
will be available during 2026.

Multi-threading within HiPO will be extended to other phases of the solver,
including the solve phase of the factorisation and the process of assemblying
including the solve phase of the factorisation and the process of assembling
the matrices.

First-order solvers for LP are still very much in their infancy, and
are not robust. Hence the availability of a PDLP solver for LP is
unlikely to be used to enhance other solvers in HiGHS in the short or
medium term.

## Alternative



Given the limited scope for parallelisation in HiGHS, if you have
multiple independent instances to solve, then assign one instance per
worker (cpu core, thread or machine) so that multiple instances are
solved concurrently.
134 changes: 93 additions & 41 deletions docs/src/solvers.md
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,84 +1,136 @@
# [Solvers](@id solvers)

## LP
## Introduction

HiGHS has implementations of the three main solution techniques for LP
(simplex, interior point and primal-dual hybrid gradient), two
solution techniques for QP (active set and interior point), and one
MIP solver. By default HiGHS will choose the most appropriate
technique for a given problem, but this can be over-ridden by setting
the option [__solver__](@ref option-solver).

HiGHS has implementations of the three main solution techniques for
LP. HiGHS will choose the most appropriate technique for a given
problem, but this can be over-ridden by setting the option
[__solver__](@ref option-solver).
What follows below is an overview of all the solvers and key
[options](@ref option-definitions) that define their algorithmic
features. The relevant [__solver__](@ref option-solver) settings for
each problem type, and their interpretation when incompatible with the
problem type, are then [summarised](@ref solver-option).

## LP

#### Simplex

HiGHS has efficient implementations of both the primal and dual
simplex methods, although the dual simplex solver is likely to be
faster and is more robust, so is used by default. The novel features
faster and is more robust, so is used by default. Similarly, for
reasons discussed in the [parallelism](@ref) section, the parallel
dual simplex solver is unlikely to be worth using. The novel features
of the dual simplex solver are described in

_Parallelizing the dual revised simplex method_, Q. Huangfu and
J. A. J. Hall, Mathematical Programming Computation, 10 (1), 119-142,
2018 [DOI:
10.1007/s12532-017-0130-5](https://link.springer.com/article/10.1007/s12532-017-0130-5).

* Setting the option [__solver__](@ref option-solver) to "simplex" forces the simplex solver to be used
* The option [__simplex\_strategy__](@ref option-simplex_strategy)
determines whether the primal solver or one of the parallel solvers is
to be used.

#### Interior point
#### [Interior point](@id solvers-lp-ipm)

HiGHS has two interior point (IPM) solvers:

* IPX is based on the preconditioned conjugate gradient method, as discussed in

_Implementation of an interior point method with basis
preconditioning_, Mathematical Programming Computation, 12, 603-635, 2020. [DOI:
preconditioning_, Mathematical Programming Computation, 12, 603-635,
2020. [DOI:
10.1007/s12532-020-00181-8](https://link.springer.com/article/10.1007/s12532-020-00181-8).

This solver is serial.

Setting the option [__solver__](@ref option-solver) to "ipx" forces the IPX solver to be used

* HiPO is based on a direct factorisation, as discussed in

_A factorisation-based regularised interior point method using the augmented system_, F. Zanetti and J. Gondzio, 2025,
[available on arxiv](https://arxiv.org/abs/2508.04370)
_A factorisation-based regularised interior point method using the
augmented system_, F. Zanetti and J. Gondzio, 2025, [available on
arxiv](https://arxiv.org/abs/2508.04370)

This solver is parallel.

Setting the option [__solver__](@ref option-solver) to "hipo" forces the HiPO solver to be used.

The [hipo\_system](@ref option-hipo-system) option can be used to select the approach to use when solving the Newton systems
within the interior point solver: select "augmented" to force the solver to use the augmented system, "normaleq" for normal
equations, or "choose" to leave the choice to the solver.

The option [hipo\_ordering](@ref option-hipo-ordering) can be used to select the fill-reducing heuristic to use during the factorisation:
* Nested dissection, obtained setting the option [hipo\_ordering](@ref option-hipo-ordering) to "metis".
* Approximate mininum degree, obtained setting the option [hipo\_ordering](@ref option-hipo-ordering) to "amd".
* Reverse Cuthill-McKee, obtained setting the option [hipo\_ordering](@ref option-hipo-ordering) to "rcm".

Setting the option [__solver__](@ref option-solver) to "ipm" selects the HiPO solver, if the build supports it, otherwise it selects the IPX solver.
The [__hipo\_system__](@ref option-hipo-system) option can be used to
select the approach to use when solving the Newton systems within
the interior point solver: select "augmented" to force the solver to
use the augmented system, "normaleq" for normal equations, or
"choose" to leave the choice to the solver.

The option [__hipo\_ordering__](@ref option-hipo-ordering) can be used
to select the fill-reducing heuristic to use during the
factorisation:

* Nested dissection, obtained setting the option
[__hipo\_ordering__](@ref option-hipo-ordering) to "metis".

* Approximate minimum degree, obtained setting the option
[__hipo\_ordering__](@ref option-hipo-ordering) to "amd".

* Reverse Cuthill-McKee, obtained setting the option
[__hipo\_ordering__](@ref option-hipo-ordering) to "rcm".

For small LPs, IPX is often faster than HiPO. However, as problem size
grows, HiPO becomes more efficient, and its advantage can be more
than an order of magnitude.

#### Primal-dual hybrid gradient method

HiGHS includes the [
cuPDLP-C](https://github.com/COPT-Public/cuPDLP-C) primal-dual hybrid
gradient method for LP (PDLP). On Linux and Windows, this can be run
on an NVIDIA [GPU](@ref gpu). On a CPU, it is unlikely to be
competitive with the HiGHS interior point or simplex solvers.

Setting the option [__solver__](@ref option-solver) to "pdlp" forces the PDLP solver to be used

## MIP

The HiGHS MIP solver uses established branch-and-cut techniques. It is
largely single-threaded, although implementing a multi-threaded tree
search is work in progress.
HiGHS has a primal-dual hybrid gradient implementation for LP (PDLP)
that is run on an NVIDIA [GPU](@ref gpu) if CUDA is installed. If this
is not possible, the PDLP solver is run on a CPU, but it is unlikely
to be competitive with the HiGHS interior point or simplex solvers.

## QP

The HiGHS solver for convex QP problems uses an established primal
active set method. The new interior point solver HiPO will soon be able to
solve convex QP problems.
HiGHS has two solvers for convex QP: a primal active set method, and
an interior point method. The active set implementation uses a dense
Cholesky factorization of the reduced Hessian, and the the limit on
its dimension is determined by the option
[__qp\_nullspace\_limit__](@ref option-qp-nullspace-limit). The
interior point solver is HiPO, so see [above](@ref solvers-lp-ipm) for
the key algorithmic options.

## MIP

MIPs are solved using a sophisticated branch-and-cut solver that is
still largely single-threaded. Users can choose the solver for LP
sub-problems as follows

* LPs where an advanced basis is not known. This is generally the case
at the root node of the branch-and-bound tree, but can occur at
other times in the MIP solution process. By default the simplex
solver is used, but the [__mip\_lp\_solver__](@ref
option-mip-lp-solver) option allows the user to determine whether
one of the IPM solvers is used.

* LPs where an interior point solver must be used. This is generally
when computing the analytic centre of the constraints for the
centralised rounding heuristic. By default IPX is used, but the
[__mip\_ipm\_solver__](@ref option-mip-ipm-solver) option allows the
user to determine whether HiPO is used.

Otherwise, for LPs where an advanced basis is known, only the simplex
solver can be used.

## [Summary](@id solver-option)

The option [__solver__](@ref option-solver) can be set to:
* "simplex", which selects the simplex solver.
* "ipm", which selects the HiPO solver (or IPX if HiPO is not available in the build).
* "ipx", which selects the IPX solver.
* "hipo", which selects the HiPO solver, for both LP and QP.
* "pdlp", which selects the PDLP solver.
* "qpasm", which selects the QP active-set method.
* "choose", which selects the default solver for the given problem ("simplex" for LP, "qpasm" for QP).

The option [__solver__](@ref option-solver) is ignored and the default solver is used if:
* The problem is an LP and solver is set to "qpasm".
* The problem is a QP and solver is set to "simplex", "ipx" or "pdlp".
* The problem is a MIP and solver is not set to "choose".

2 changes: 1 addition & 1 deletion highs/lp_data/Highs.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -374,7 +374,7 @@ HighsStatus Highs::passModel(HighsModel model) {
// Ensure that any non-zero Hessian of dimension less than the
// number of columns in the model is completed
if (hessian.dim_) completeHessian(this->model_.lp_.num_col_, hessian);
// if (model_.lp_.num_row_>0 && model_.lp_.num_col_>0)
// if (model_.lp_.num_row_>0 && model_.lp_.num_col_>0)
// writeLpMatrixPicToFile(options_, "LpMatrix", model_.lp_);

// Clear solver status, solution, basis and info associated with any
Expand Down
13 changes: 7 additions & 6 deletions highs/lp_data/HighsOptions.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1313,17 +1313,18 @@ class HighsOptions : public HighsOptionsStruct {
records.push_back(record_double);

record_int = new OptionRecordInt(
"qp_iteration_limit", "Iteration limit for QP solver", advanced,
&qp_iteration_limit, 0, kHighsIInf, kHighsIInf);
"qp_iteration_limit", "Iteration limit for the active set QP solver",
advanced, &qp_iteration_limit, 0, kHighsIInf, kHighsIInf);
records.push_back(record_int);

record_int = new OptionRecordInt("qp_nullspace_limit",
"Nullspace limit for QP solver", advanced,
&qp_nullspace_limit, 0, 4000, kHighsIInf);
record_int = new OptionRecordInt(
"qp_nullspace_limit", "Nullspace limit for the active set QP solver",
advanced, &qp_nullspace_limit, 0, 4000, kHighsIInf);
records.push_back(record_int);

record_double = new OptionRecordDouble(
"qp_regularization_value", "Regularization value added to the Hessian",
"qp_regularization_value",
"Regularization value added to the Hessian in the active set QP solver",
advanced, &qp_regularization_value, 0, kHessianRegularizationValue,
kHighsInf);
records.push_back(record_double);
Expand Down
Loading