lpsolver 0.1.0 → 0.2.1

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

@@ -0,0 +1,185 @@
+# HiGHS Active set QP solver (QUASS)
+
+This document is not a full accout of how active set methods solver
+QPs (see, for example, Fletcher's _Practical Methods of Optimization_,
+Chapter 10), rather some background information to help understand the
+essence of the HiGHS solver. For a
+
+## Active set vs simplex for LP
+
+To document the active set QP solver, it is convenient to start with
+observations on the active set method (ASM) for LP. Although the ASM
+is equivalent to the primal simplex algorithm, this is obscured by
+differences in terminology, description and underlying linear algebra.
+
+Whilst the simplex algorithm considers an LP in standard form with
+$n+m$ variables ($n$ original and $m$ slack), the ASM considers an LP
+with $m+n$ constraints ($m$ original and $n$ corresponding to variable
+bounds). Hence, whilst the simplex algorithm definition relates to
+"variables" (that are original or slack) the ASM relates to
+"constraints" (that are original or variable bounds).
+
+Whereas the simplex method is based on the factorization of a matrix
+of dimension $m$ (whose columns correspond to the basic variables) the
+ASM is based on the factorization of a matrix of dimension $n$. The
+rows of this matrix correspond to a set of active constraints
+(original constraints at a bound and variables at a bound). As such,
+the set of active constraints in the ASM is identical to the set of
+nonbasic variables in the simplex algorithm. Confusingly, and due to
+the role of this matrix, the set of $n$ active constraints in the ASM
+is referred to as the "basis". The remaining $m$ constraints in the
+ASM are analogous to the set of basic variables in the simplex
+algorithm, in that their values are solved for.
+
+For the simplex method, below is an illustration of the partition of
+the original and slack variables into basic and nonbasic variables
+
+| Basic original | Basic slack | Nonbasic slack | Nonbasic original |
+| --- | --- | --- | --- |
+| $B_0$ | $0$ | $I_N$ | $N_0$ |
+| $B_1$ | $I_B$ | $0$ | $N_1$ |
+
+Hence the simplex method factorizes the matrix
+$\left[\begin{matrix}B_0 & 0\\ B_1 &
+I_B\end{matrix}\right]\in\R^{m\times m}$.  For the ASM, below is an
+illustration of the partition of the original constraints and variable
+bounds into active and inactive constraints
+
+ASM | Simplex basic | Simplex nonbasic |
+| --- | --- | --- |
+Active original constraints | $B_0$ | $N_0$ |
+Active variable bounds| $0$ | $I_N$ |
+Inactive variable bounds | $I_B$ | $0$ |
+Inactive original constraints | $B_1$ | $N_1$ |
+
+Hence the ASM factorizes the matrix $\left[\begin{matrix}B_0 & N_0\\ 0
+& I_N\end{matrix}\right]\in\R^{n\times n}$.  Note that the
+factorization requirement for simplex and ASM is essentially the same,
+since it is restricted to the "kernel" matrix $B_0$. This is due to
+the matrices $I_B$ for simplex and $I_N$ for ASM yielding singleton
+pivots in Gaussian elimination.
+
+## An active set method for QP
+
+The QP problem solved by HiGHS is
+
+$$
+\min \quad q(x) = \dfrac{1}{2}x^TQx + c^Tx \qquad \textrm{s.t.}~ \quad L \leq Ax \leq U; \quad l \leq x \leq u,\qquad(1)
+$$
+
+where $Q$ must be positive semi-definite. Unlike LP where (if an
+optimal solution exists) there is an optimal solution at a vertex of
+the feasible region, in general the optimal solution of a QP is not a
+vertex. This is trivially so in the case of unconstrained convex QP
+problems. When a QP has linear constraints, so long as the no solution
+of the unconstrained QP is feasible, there will be at least one active
+constraint at an optimal solution. The null space orthogonal to these
+active constraints is fundamental to the properties of an optimal
+solution, and the characterisation of constraint null spaces is
+critical to finding an optimal solution.
+
+### Karush-Kuhn-Tucker (KKT) conditions for convex QP
+
+A point $x$ is an optimal solution of (1) iff $x$ is feasible and
+there is a set $\cal{A}$ of indices of active constraints (and
+bounds), and Lagrange multipliers $\lambda$, such that
+$Qx+c=A_{\cal{A}}^T\lambda$ (where $A_{\cal{A}}$ is the matrix
+corresponding to the active constraints) and the signs of the
+components of $\lambda$ are consistent with the bounds at which the
+constraint is active. Note that $\cal{A}$ need only include the
+indices of active constraints with nonzero Lagrange multiplier, so it
+can be assumed that $A_{\cal{A}}$ is of full rank.
+
+The aim of a QP active set method is to find $\cal{A}$ such that
+$A_{\cal{A}}$ is of full rank and the KKT conditions hold. 
+
+### Some linear algebra and calculus
+
+For a set $\cal{A}$ and matrix $A_{\cal{A}}$, there is a "null space"
+normal to the row space of $A_{\cal{A}}$. This null space plays a
+major role in defining an active set method for QP. Suppose that
+$r=|\cal{A}|$, so $A_{\cal{A}}\in\R^{r\times n}$, and the matrix
+$Y^T\in\R^{r\times n}$ spans the row space of $A_{\cal{A}}$ such that
+$A_{\cal{A}}Y=I$ (so $Y$ is the right inverse of $A_{\cal{A}}$). Let
+$Z^T\in\R^{(n-r)\times n}$ span the null space of $A_{\cal{A}}$, so
+$A_{\cal{A}}Z=0$.
+
+With these definitions, note that the point $x=Yb_{\cal{A}} + Zy$,
+where $b_{\cal{A}}$ are the active bounds for the constraints indexed
+by $\cal{A}$, satisfies
+$$
+A_{\cal{A}}x=A_{\cal{A}}Yb_{\cal{A}} + A_{\cal{A}}Zy = b_{\cal{A}}.
+$$
+Hence $y$ parameterises $x$ in the null space.
+
+Active set methods form and operate with $Y$ and $Z$ by identifying a
+matrix $V\in\R^{(n-r)\times n}$ such that
+$\displaystyle B_{\cal{A}}=\left[\begin{matrix}A_{\cal{A}}\\V\end{matrix}\right]$
+is well conditioned, so that
+$\left[\begin{matrix}Y&Z\end{matrix}\right]=B_{\cal{A}}^{-1}$. Note
+that $Y$ and $Z$ are not formed explicitly since, for example,
+$Yb_{\cal{A}}$ can be formed by factorizing $B$ and solving
+$$
+B_{\cal{A}}y=\left[\begin{matrix}b_{\cal{A}}\\0\end{matrix}\right]\qquad(2)
+$$
+
+Note that substituting $x=Yb_{\cal{A}} + Zy$ into the objective yields
+$$
+q(y) = \frac{1}{2} y^TZ^TQZy +(c+QYb_{\cal{A}})^TZy +\left(c+\frac{1}{2}QYb_{\cal{A}}\right)^TYb_{\cal{A}}
+$$
+Hence the minimizer of $q(y)$ is a solution of
+$$
+Z^TQZy = -Z^T(c+QYb_{\cal{A}})\qquad(3)
+$$
+The matrix $Z^TQZ$ is known as the **reduced Hessian**.
+
+### Outline ASM algorithm
+
+The following algorithmic definition is from Fletcher's _Practical
+Methods of Optimization_, Chapter 10, which also illustrates it
+qualitatively. Key to the definition is the **equality problem**, 
+$$
+\min~ \frac{1}{2}\delta^TQ\delta + \delta^Tg^{(k)}\quad \textrm{s.t.}~ a_i^T\delta=0, i\in\cal{A},
+$$
+where $g^{(k)}=Qx^{(k)}+c$. This problem minimizes the QP objective in the null space of the active constraints at a point $x^{(k)}$. Also, the set of inequalities in the QP is denoted $\cal{I}$.
+
+1. Given feasible $x^{(1)}$ and $\cal{A}$, set $k=1$
+2. If $\delta=0$ does not solve the equality proble, go to 4.
+3. Compute Lagrange multipliers $\lambda^{(k)}$ for the equality
+problem and use the following to determine $q$. If
+$\textrm{sgn}(q)\lambda^{(k)}_q\ge0$, then terminate with
+$x^*=x^{(k)}$, otherwise remove $q$ from $\cal{A}$.
+$$
+q=\argmin_{\cal{A}\cap\cal{I}} \textrm{sgn}(i)\lambda^{(k)}_i\quad\textrm{where}~\textrm{sgn}(i) = \begin{cases}\phantom{-}1,~~a_i^Tx=L_i\\ -1,~~a_i^Tx=U_i\end{cases}
+$$
+4. Solve the equality problem for $s^{(k)}$
+5. Find $\alpha^{(k)}$ to solve the following **linesearch problem** and set $x^{(k+1)} = x^{(k)} + \alpha^{(k)}s^{(k)}$.
+$$
+\alpha^{(k)} = \min\left(1, 
+\min_{i: i\not\in\cal{A}, a_i^Ts^{(k)}<0} \frac{L_i-a_i^Tx^{(k)}}{a_i^Ts^{(k)}},
+\min_{i: i\not\in\cal{A}, a_i^Ts^{(k)}>0} \frac{U_i-a_i^Tx^{(k)}}{a_i^Ts^{(k)}}
+\right)
+$$
+6. If $\alpha^{(k)}<1$ then add $p$ to $\cal{A}$, where $p\not\in\cal{A}$ yields $\alpha^{(k)}$
+7. Set $k=k+1$ and go to 2.
+
+In essence, the algorithm solves the equality problem repeatedly,
+allowing constraints to become inactive if they will improve the
+objective (deducing optimality if none will do so) and forcing
+constraints to be active if they would be violated at the minimizer of
+the equality problem. It can be seen to be a generalisation of the
+primal simplex method, where nonbasic variables are allowed to move
+from bounds at vertices to improve the objective, to be replaced by
+basic variables which reach bounds. Since the primal simplex method is
+always at a vertex, the null space is trivial, and since there is no
+local minimizer along an edge of the polytope, a limiting basic
+variables is always found (for an LP that is not unbounded).
+
+### Practicalities
+
+The algorithm assumes that $x^{(1)}$ is feasible. This can be found by
+using the simplex algorithm to solve the LP feasibility problem. This
+yields a vertex solution, so the initial null space is empty. The
+simplex nonbasic variables yield $\cal{A}$, for which the matrix
+$B_{\cal{A}}$ is nonsingular since it has the same kernel as the
+simplex basis matrix.

data/ext/lpsolver-highs/highs/qpsolver/a_asm.cpp

@@ -0,0 +1,139 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "qpsolver/a_asm.hpp"
+
+#include "qpsolver/quass.hpp"
+#include "util/HighsCDouble.h"
+
+QpAsmStatus solveqp_actual(Instance& instance, Settings& settings,
+                           QpHotstartInformation& startinfo, Statistics& stats,
+                           QpModelStatus& status, QpSolution& solution,
+                           HighsTimer& qp_timer) {
+  Runtime rt(instance, stats);
+  rt.settings = settings;
+  Quass quass(rt);
+
+  Basis basis(rt, startinfo.active, startinfo.status, startinfo.inactive);
+
+  quass.solve(startinfo.primal, startinfo.rowact, basis, qp_timer);
+
+  status = rt.status;
+
+  solution.status_var = rt.status_var;
+  solution.status_con = rt.status_con;
+  solution.primal = rt.primal;
+  solution.dualvar = rt.dualvar;
+  solution.rowactivity = rt.rowactivity;
+  solution.dualcon = rt.dualcon;
+
+  return QpAsmStatus::kOk;
+}
+
+std::string qpBasisStatusToString(const BasisStatus qp_basis_status) {
+  switch (qp_basis_status) {
+    case BasisStatus::kInactive:
+      return "Inactive";
+    case BasisStatus::kActiveAtLower:
+      return "Active at lower bound";
+    case BasisStatus::kActiveAtUpper:
+      return "Active at upper bound";
+    case BasisStatus::kInactiveInBasis:
+      return "Inactive in basis";
+    default:
+      return "Unidentified QP basis status";
+  }
+}
+
+std::string qpModelStatusToString(const QpModelStatus qp_model_status) {
+  switch (qp_model_status) {
+    case QpModelStatus::kNotset:
+      return "Not set";
+    case QpModelStatus::kUndetermined:
+      return "Undetermined";
+    case QpModelStatus::kOptimal:
+      return "Optimal";
+    case QpModelStatus::kUnbounded:
+      return "Unbounded";
+    case QpModelStatus::kInfeasible:
+      return "Infeasible";
+    case QpModelStatus::kIterationLimit:
+      return "Iteration limit";
+    case QpModelStatus::kTimeLimit:
+      return "Time ;limit";
+    case QpModelStatus::kLargeNullspace:
+      return "Large nullspace";
+    case QpModelStatus::kError:
+      return "Error";
+    default:
+      return "Unidentified QP model status";
+  }
+}
+
+void assessQpPrimalFeasibility(
+    const Instance& instance, const double primal_feasibility_tolerance,
+    const std::vector<double>& var_value, const std::vector<double>& con_value,
+    HighsInt& num_var_infeasibilities, double& max_var_infeasibility,
+    double& sum_var_infeasibilities, HighsInt& num_con_infeasibilities,
+    double& max_con_infeasibility, double& sum_con_infeasibilities,
+    double& max_con_residual, double& sum_con_residuals) {
+  num_var_infeasibilities = 0;
+  max_var_infeasibility = 0;
+  sum_var_infeasibilities = 0;
+  num_con_infeasibilities = 0;
+  max_con_infeasibility = 0;
+  sum_con_infeasibilities = 0;
+  max_con_residual = 0;
+  sum_con_residuals = 0;
+  // Valid solution, but is it feasible?
+  std::vector<HighsCDouble> con_value_quad;
+  con_value_quad.assign(instance.num_con, HighsCDouble{0.0});
+  for (HighsInt iVar = 0; iVar < instance.num_var; iVar++) {
+    double lower = instance.var_lo[iVar];
+    double upper = instance.var_up[iVar];
+    double primal = var_value[iVar];
+    double var_infeasibility = 0;
+    if (primal < lower - primal_feasibility_tolerance) {
+      var_infeasibility = lower - primal;
+    } else if (primal > upper + primal_feasibility_tolerance) {
+      var_infeasibility = primal - upper;
+    }
+    if (var_infeasibility > 0) {
+      if (var_infeasibility > primal_feasibility_tolerance)
+        num_var_infeasibilities++;
+      max_var_infeasibility =
+          std::max(var_infeasibility, max_var_infeasibility);
+      sum_var_infeasibilities += var_infeasibility;
+    }
+    for (HighsInt iEl = instance.A.mat.start[iVar];
+         iEl < instance.A.mat.start[iVar + 1]; iEl++) {
+      con_value_quad[instance.A.mat.index[iEl]] +=
+          primal * instance.A.mat.value[iEl];
+    }
+  }
+  for (HighsInt iCon = 0; iCon < instance.num_con; iCon++) {
+    double lower = instance.con_lo[iCon];
+    double upper = instance.con_up[iCon];
+    double primal = con_value[iCon];
+    double con_infeasibility = 0;
+    if (primal < lower - primal_feasibility_tolerance) {
+      con_infeasibility = lower - primal;
+    } else if (primal > upper + primal_feasibility_tolerance) {
+      con_infeasibility = primal - upper;
+    }
+    if (con_infeasibility > 0) {
+      if (con_infeasibility > primal_feasibility_tolerance)
+        num_con_infeasibilities++;
+      max_con_infeasibility =
+          std::max(con_infeasibility, max_con_infeasibility);
+      sum_con_infeasibilities += con_infeasibility;
+    }
+    double con_residual = std::fabs(primal - double(con_value_quad[iCon]));
+    max_con_residual = std::max(con_residual, max_con_residual);
+    sum_con_residuals += con_residual;
+  }
+}

data/ext/lpsolver-highs/highs/qpsolver/a_asm.hpp

@@ -0,0 +1,77 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef __SRC_LIB_QPSOLVER_ASM_HPP__
+#define __SRC_LIB_QPSOLVER_ASM_HPP__
+
+#include "qpsolver/instance.hpp"
+#include "qpsolver/qpconst.hpp"
+#include "qpsolver/settings.hpp"
+#include "qpsolver/statistics.hpp"
+#include "util/HighsTimer.h"
+
+enum class QpAsmStatus {
+  kOk,
+  kWarning,
+  kError
+  //  NEGATIVEEIGENVALUEINREDUCEDHESSIAN,
+  //  BASISRANKDEFICIENT
+};
+
+struct QpSolution {
+  QpVector primal;
+  QpVector rowactivity;
+  QpVector dualvar;
+  QpVector dualcon;
+
+  std::vector<BasisStatus> status_var;
+  std::vector<BasisStatus> status_con;
+
+  QpSolution(Instance& instance)
+      : primal(QpVector(instance.num_var)),
+        rowactivity(QpVector(instance.num_con)),
+        dualvar(instance.num_var),
+        dualcon(instance.num_con),
+        status_var(instance.num_var),
+        status_con(instance.num_con) {}
+};
+
+struct QpHotstartInformation {
+  std::vector<HighsInt> active;
+  std::vector<HighsInt> inactive;
+  std::vector<BasisStatus> status;
+  QpVector primal;
+  QpVector rowact;
+
+  QpHotstartInformation(HighsInt num_var, HighsInt num_row)
+      : primal(QpVector(num_var)), rowact(QpVector(num_row)) {}
+};
+
+// the purpose of this is the pure algorithmic solution of a QP instance with
+// given hotstart information. scenarios: 1) start from a given phase1 solution
+// 2) start from a user-given hotstart solution
+// 3) start from a qp solution that was attained from a scaled instance and
+// cleanup 4) start from a qp solution that was attained from a perturbed
+// instance and cleanup 5) start from a qp solution and cleanup after
+// recomputing basis and reduced hessian factorization
+
+std::string qpBasisStatusToString(const BasisStatus qp_basis_status);
+std::string qpModelStatusToString(const QpModelStatus qp_model_status);
+void assessQpPrimalFeasibility(
+    const Instance& instance, const double primal_feasibility_tolerance,
+    const std::vector<double>& var_value, const std::vector<double>& con_value,
+    HighsInt& num_var_infeasibilities, double& max_var_infeasibility,
+    double& sum_var_infeasibilities, HighsInt& num_con_infeasibilities,
+    double& max_con_infeasibility, double& sum_con_infeasibilities,
+    double& max_con_residual, double& sum_con_residuals);
+
+QpAsmStatus solveqp_actual(Instance& instance, Settings& settings,
+                           QpHotstartInformation& startinfo, Statistics& stats,
+                           QpModelStatus& status, QpSolution& solution,
+                           HighsTimer& qp_timer);
+
+#endif

data/ext/lpsolver-highs/highs/qpsolver/a_quass.cpp

@@ -0,0 +1,194 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#include "qpsolver/a_quass.hpp"
+
+#include "qpsolver/a_asm.hpp"
+#include "qpsolver/feasibility_bounded.hpp"
+#include "qpsolver/feasibility_highs.hpp"
+
+static QpAsmStatus quass2highs(Instance& instance, Settings& settings,
+                               Statistics& stats,
+                               QpModelStatus& qp_model_status,
+                               QpSolution& qp_solution,
+                               HighsModelStatus& highs_model_status,
+                               HighsBasis& highs_basis,
+                               HighsSolution& highs_solution) {
+  settings.qp_model_status_log.fire(qp_model_status);
+  QpAsmStatus qp_asm_return_status = QpAsmStatus::kError;
+  switch (qp_model_status) {
+    case QpModelStatus::kOptimal:
+      highs_model_status = HighsModelStatus::kOptimal;
+      qp_asm_return_status = QpAsmStatus::kOk;
+      break;
+    case QpModelStatus::kUnbounded:
+      highs_model_status = HighsModelStatus::kUnbounded;
+      qp_asm_return_status = QpAsmStatus::kOk;
+      break;
+    case QpModelStatus::kInfeasible:
+      highs_model_status = HighsModelStatus::kInfeasible;
+      qp_asm_return_status = QpAsmStatus::kOk;
+      break;
+    case QpModelStatus::kIterationLimit:
+      highs_model_status = HighsModelStatus::kIterationLimit;
+      qp_asm_return_status = QpAsmStatus::kWarning;
+      break;
+    case QpModelStatus::kTimeLimit:
+      highs_model_status = HighsModelStatus::kTimeLimit;
+      qp_asm_return_status = QpAsmStatus::kWarning;
+      break;
+    case QpModelStatus::kInterrupt:
+      highs_model_status = HighsModelStatus::kInterrupt;
+      qp_asm_return_status = QpAsmStatus::kWarning;
+      break;
+    case QpModelStatus::kUndetermined:
+      highs_model_status = HighsModelStatus::kSolveError;
+      qp_asm_return_status = QpAsmStatus::kError;
+      return QpAsmStatus::kError;
+    case QpModelStatus::kLargeNullspace:
+      highs_model_status = HighsModelStatus::kSolveError;
+      return QpAsmStatus::kError;
+    case QpModelStatus::kError:
+      highs_model_status = HighsModelStatus::kSolveError;
+      return QpAsmStatus::kError;
+    case QpModelStatus::kNotset:
+      highs_model_status = HighsModelStatus::kNotset;
+      return QpAsmStatus::kError;
+    default:
+      highs_model_status = HighsModelStatus::kNotset;
+      return QpAsmStatus::kError;
+  }
+
+  assert(qp_asm_return_status != QpAsmStatus::kError);
+  // extract variable values
+  highs_solution.col_value.resize(instance.num_var);
+  highs_solution.col_dual.resize(instance.num_var);
+  for (HighsInt iCol = 0; iCol < instance.num_var; iCol++) {
+    highs_solution.col_value[iCol] = qp_solution.primal.value[iCol];
+    highs_solution.col_dual[iCol] =
+        instance.sense * qp_solution.dualvar.value[iCol];
+  }
+  // extract constraint activity
+  highs_solution.row_value.resize(instance.num_con);
+  highs_solution.row_dual.resize(instance.num_con);
+  // Negate the vector and Hessian
+  for (HighsInt iRow = 0; iRow < instance.num_con; iRow++) {
+    highs_solution.row_value[iRow] = qp_solution.rowactivity.value[iRow];
+    highs_solution.row_dual[iRow] =
+        instance.sense * qp_solution.dualcon.value[iRow];
+  }
+  highs_solution.value_valid = true;
+  highs_solution.dual_valid = true;
+
+  // extract basis status
+  highs_basis.col_status.resize(instance.num_var);
+  highs_basis.row_status.resize(instance.num_con);
+
+  const bool debug_report =
+      false;  // instance.num_var + instance.num_con < 100;
+  for (HighsInt i = 0; i < instance.num_var; i++) {
+    if (debug_report)
+      printf("Column %2d: status %s\n", int(i),
+             qpBasisStatusToString(qp_solution.status_var[i]).c_str());
+    if (qp_solution.status_var[i] == BasisStatus::kActiveAtLower) {
+      highs_basis.col_status[i] = HighsBasisStatus::kLower;
+    } else if (qp_solution.status_var[i] == BasisStatus::kActiveAtUpper) {
+      highs_basis.col_status[i] = HighsBasisStatus::kUpper;
+    } else if (qp_solution.status_var[i] == BasisStatus::kInactiveInBasis) {
+      highs_basis.col_status[i] = HighsBasisStatus::kNonbasic;
+    } else {
+      assert(qp_solution.status_var[i] == BasisStatus::kInactive);
+      highs_basis.col_status[i] = HighsBasisStatus::kBasic;
+    }
+  }
+
+  for (HighsInt i = 0; i < instance.num_con; i++) {
+    if (debug_report)
+      printf("Row    %2d: status %s\n", int(i),
+             qpBasisStatusToString(qp_solution.status_con[i]).c_str());
+    if (qp_solution.status_con[i] == BasisStatus::kActiveAtLower) {
+      highs_basis.row_status[i] = HighsBasisStatus::kLower;
+    } else if (qp_solution.status_con[i] == BasisStatus::kActiveAtUpper) {
+      highs_basis.row_status[i] = HighsBasisStatus::kUpper;
+    } else if (qp_solution.status_con[i] == BasisStatus::kInactiveInBasis) {
+      highs_basis.row_status[i] = HighsBasisStatus::kNonbasic;
+    } else {
+      assert(qp_solution.status_con[i] == BasisStatus::kInactive);
+      highs_basis.row_status[i] = HighsBasisStatus::kBasic;
+    }
+  }
+  highs_basis.valid = true;
+  highs_basis.alien = false;
+  highs_basis.useful = true;
+  return qp_asm_return_status;
+}
+
+QpAsmStatus solveqp(Instance& instance, Settings& settings, Statistics& stats,
+                    HighsModelStatus& highs_model_status,
+                    HighsBasis& highs_basis, HighsSolution& highs_solution,
+                    HighsTimer& qp_timer) {
+  QpModelStatus qp_model_status = QpModelStatus::kUndetermined;
+
+  QpSolution qp_solution(instance);
+
+  // presolve
+
+  // scale instance, store scaling factors
+
+  // perturb instance, store perturbance information
+
+  // regularize
+  for (HighsInt i = 0; i < instance.num_var; i++) {
+    for (HighsInt index = instance.Q.mat.start[i];
+         index < instance.Q.mat.start[i + 1]; index++) {
+      if (instance.Q.mat.index[index] == i) {
+        instance.Q.mat.value[index] += settings.hessian_regularization_value;
+      }
+    }
+  }
+
+  // compute initial feasible point
+  QpHotstartInformation startinfo(instance.num_var, instance.num_con);
+  if (instance.num_con == 0 && instance.num_var <= 15000) {
+    computeStartingPointBounded(instance, settings, stats, qp_model_status,
+                                startinfo, qp_timer);
+    if (qp_model_status == QpModelStatus::kOptimal) {
+      qp_solution.primal = startinfo.primal;
+      return quass2highs(instance, settings, stats, qp_model_status,
+                         qp_solution, highs_model_status, highs_basis,
+                         highs_solution);
+    }
+    if (qp_model_status == QpModelStatus::kUnbounded) {
+      return quass2highs(instance, settings, stats, qp_model_status,
+                         qp_solution, highs_model_status, highs_basis,
+                         highs_solution);
+    }
+  } else {
+    computeStartingPointHighs(instance, settings, stats, qp_model_status,
+                              startinfo, highs_model_status, highs_basis,
+                              highs_solution, qp_timer);
+    if (qp_model_status != QpModelStatus::kNotset) {
+      return quass2highs(instance, settings, stats, qp_model_status,
+                         qp_solution, highs_model_status, highs_basis,
+                         highs_solution);
+    }
+  }
+
+  // solve
+  solveqp_actual(instance, settings, startinfo, stats, qp_model_status,
+                 qp_solution, qp_timer);
+
+  // undo perturbation and resolve
+
+  // undo scaling and resolve
+
+  // postsolve
+
+  // Transform QP status and qp_solution to HiGHS highs_basis and highs_solution
+  return quass2highs(instance, settings, stats, qp_model_status, qp_solution,
+                     highs_model_status, highs_basis, highs_solution);
+}

data/ext/lpsolver-highs/highs/qpsolver/a_quass.hpp

@@ -0,0 +1,22 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef __SRC_LIB_QPSOLVER_QUASS_HPP__
+#define __SRC_LIB_QPSOLVER_QUASS_HPP__
+
+#include "Highs.h"
+#include "qpsolver/a_asm.hpp"
+#include "qpsolver/instance.hpp"
+#include "qpsolver/qpconst.hpp"
+#include "qpsolver/settings.hpp"
+
+QpAsmStatus solveqp(Instance& instance, Settings& settings, Statistics& stats,
+                    HighsModelStatus& highs_model_status,
+                    HighsBasis& highs_basis, HighsSolution& highs_solution,
+                    HighsTimer& timer);
+
+#endif