casadi 3.6.5__cp36-none-win_amd64.whl → 3.6.7__cp36-none-win_amd64.whl

casadi/include/highs/qpsolver/dantzigpricing.hpp

@@ -0,0 +1,72 @@
+#ifndef __SRC_LIB_PRICING_DANTZIGPRICING_HPP__
+#define __SRC_LIB_PRICING_DANTZIGPRICING_HPP__
+
+#include "basis.hpp"
+#include "pricing.hpp"
+#include "reducedcosts.hpp"
+#include "runtime.hpp"
+
+// 51561, 78965838.346823, 559, 213.280772, 0.000812, 801
+
+class DantzigPricing : public Pricing {
+ private:
+  Runtime& runtime;
+  Basis& basis;
+  ReducedCosts& redcosts;
+
+  HighsInt chooseconstrainttodrop(const QpVector& lambda) {
+    auto active_constraint_index = basis.getactive();
+    auto constraintindexinbasisfactor = basis.getindexinfactor();
+
+    HighsInt minidx = -1;
+    double maxabslambda = 0.0;
+    for (size_t i = 0; i < active_constraint_index.size(); i++) {
+      HighsInt indexinbasis =
+          constraintindexinbasisfactor[active_constraint_index[i]];
+      if (indexinbasis == -1) {
+        printf("error\n");
+      }
+      assert(indexinbasis != -1);
+
+      if (basis.getstatus(active_constraint_index[i]) ==
+              BasisStatus::kActiveAtLower &&
+          -lambda.value[indexinbasis] > maxabslambda) {
+        minidx = active_constraint_index[i];
+        maxabslambda = -lambda.value[indexinbasis];
+      } else if (basis.getstatus(active_constraint_index[i]) ==
+                     BasisStatus::kActiveAtUpper &&
+                 lambda.value[indexinbasis] > maxabslambda) {
+        minidx = active_constraint_index[i];
+        maxabslambda = lambda.value[indexinbasis];
+      } else {
+        // TODO
+      }
+    }
+
+    if (maxabslambda <= runtime.settings.lambda_zero_threshold) {
+      // printf("maxabslambda %lf\n", log(maxabslambda));
+      return -1;
+    }
+    return minidx;
+  }
+
+ public:
+  DantzigPricing(Runtime& rt, Basis& bas, ReducedCosts& rc)
+      : runtime(rt), basis(bas), redcosts(rc){};
+
+  HighsInt price(const QpVector& x, const QpVector& gradient) {
+    HighsInt minidx = chooseconstrainttodrop(redcosts.getReducedCosts());
+    return minidx;
+  }
+
+  void recompute() {
+    // do nothing
+  }
+
+  void update_weights(const QpVector& aq, const QpVector& ep, HighsInt p,
+                      HighsInt q) {
+    // does nothing
+  }
+};
+
+#endif

casadi/include/highs/qpsolver/devexpricing.hpp

@@ -0,0 +1,99 @@
+#ifndef __SRC_LIB_PRICING_DEVEXPRICING_HPP__
+#define __SRC_LIB_PRICING_DEVEXPRICING_HPP__
+
+#include "qpsolver/basis.hpp"
+#include "qpsolver/pricing.hpp"
+#include "qpsolver/reducedcosts.hpp"
+#include "qpsolver/runtime.hpp"
+
+// 42726, 78965776.391299, 559, 104.321553, 0.000669, 7937
+
+class DevexPricing : public Pricing {
+ private:
+  Runtime& runtime;
+  Basis& basis;
+  ReducedCosts& redcosts;
+
+  std::vector<double> weights;
+
+  HighsInt chooseconstrainttodrop(const QpVector& lambda) {
+    auto active_constraint_index = basis.getactive();
+    auto constraintindexinbasisfactor = basis.getindexinfactor();
+
+    HighsInt minidx = -1;
+    double maxabslambda = 0.0;
+    for (size_t i = 0; i < active_constraint_index.size(); i++) {
+      HighsInt indexinbasis =
+          constraintindexinbasisfactor[active_constraint_index[i]];
+      if (indexinbasis == -1) {
+        printf("error\n");
+      }
+      assert(indexinbasis != -1);
+
+      double val = lambda.value[indexinbasis] * lambda.value[indexinbasis] /
+                   weights[indexinbasis];
+      if (val > maxabslambda && fabs(lambda.value[indexinbasis]) >
+                                    runtime.settings.lambda_zero_threshold) {
+        if (basis.getstatus(active_constraint_index[i]) ==
+                BasisStatus::kActiveAtLower &&
+            -lambda.value[indexinbasis] > 0) {
+          minidx = active_constraint_index[i];
+          maxabslambda = val;
+        } else if (basis.getstatus(active_constraint_index[i]) ==
+                       BasisStatus::kActiveAtUpper &&
+                   lambda.value[indexinbasis] > 0) {
+          minidx = active_constraint_index[i];
+          maxabslambda = val;
+        } else {
+          // TODO
+        }
+      }
+    }
+
+    return minidx;
+  }
+
+ public:
+  DevexPricing(Runtime& rt, Basis& bas, ReducedCosts& rc)
+      : runtime(rt),
+        basis(bas),
+        redcosts(rc),
+        weights(std::vector<double>(rt.instance.num_var, 1.0)){};
+
+  // B lambda = g
+  // lambda = inv(B)g
+  // lambda = Z'g == reduced gradient ??
+  // no: lambda = Y'g !!
+  // dual values updated as:
+  // c_N^T  += alpha_D * a_p^T (pivotal row)
+  // alpha_D = -c_q / a_pq
+  HighsInt price(const QpVector& x, const QpVector& gradient) {
+    QpVector& lambda = redcosts.getReducedCosts();
+    HighsInt minidx = chooseconstrainttodrop(lambda);
+    return minidx;
+  }
+
+  void recompute() {
+    // do nothing
+  }
+
+  void update_weights(const QpVector& aq, const QpVector& ep, HighsInt p,
+                      HighsInt q) {
+    HighsInt rowindex_p = basis.getindexinfactor()[p];
+    double weight_p = weights[rowindex_p];
+    for (HighsInt i = 0; i < runtime.instance.num_var; i++) {
+      if (i == rowindex_p) {
+        weights[i] = weight_p / (aq.value[rowindex_p] * aq.value[rowindex_p]);
+      } else {
+        weights[i] += (aq.value[i] * aq.value[i]) /
+                      (aq.value[rowindex_p] * aq.value[rowindex_p]) * weight_p *
+                      weight_p;
+      }
+      if (weights[i] > 1e7) {
+        weights[i] = 1.0;
+      }
+    }
+  }
+};
+
+#endif

casadi/include/highs/qpsolver/eventhandler.hpp

@@ -0,0 +1,23 @@
+#ifndef __SRC_LIB_EVENTHANDLER_HPP__
+#define __SRC_LIB_EVENTHANDLER_HPP__
+
+#include <functional>
+#include <vector>
+
+template <typename T>  // T: void (*fncptr)(int, double)
+class Eventhandler {
+  std::vector<std::function<void(T)>> subscribers;
+
+ public:
+  void subscribe(std::function<void(T)> subscriber) {
+    subscribers.push_back(subscriber);
+  }
+
+  void fire(T args) {
+    for (std::function<void(T)> fun : subscribers) {
+      fun(args);
+    }
+  }
+};
+
+#endif

casadi/include/highs/qpsolver/factor.hpp

@@ -0,0 +1,400 @@
+#ifndef __SRC_LIB_NEWFACTOR_HPP__
+#define __SRC_LIB_NEWFACTOR_HPP__
+
+#include <cassert>
+#include <vector>
+
+#include "matrix.hpp"
+#include "qpconst.hpp"
+#include "runtime.hpp"
+
+using std::min;
+
+class CholeskyFactor {
+ private:
+  bool uptodate = false;
+  HighsInt numberofreduces = 0;
+
+  Runtime& runtime;
+
+  Basis& basis;
+
+  HighsInt current_k = 0;
+  HighsInt current_k_max;
+  std::vector<double> L;
+
+  bool has_negative_eigenvalue = false;
+  std::vector<double> a;
+
+  void resize(HighsInt new_k_max) {
+    std::vector<double> L_old = L;
+    L.clear();
+    L.resize((new_k_max) * (new_k_max));
+    const HighsInt l_size = L.size();
+    // Driven by #958, changes made in following lines to avoid array
+    // bound error when new_k_max < current_k_max
+    HighsInt min_k_max = min(new_k_max, current_k_max);
+    for (HighsInt i = 0; i < min_k_max; i++) {
+      for (HighsInt j = 0; j < min_k_max; j++) {
+	assert(i * (new_k_max) + j < l_size);
+        L[i * (new_k_max) + j] = L_old[i * current_k_max + j];
+      }
+    }
+    current_k_max = new_k_max;
+  }
+
+ public:
+  CholeskyFactor(Runtime& rt, Basis& bas) : runtime(rt), basis(bas) {
+    uptodate = false;
+    current_k_max =
+        max(min((HighsInt)ceil(rt.instance.num_var / 16.0), (HighsInt)1000),
+            basis.getnuminactive());
+    L.resize(current_k_max * current_k_max);
+  }
+
+
+  void recompute() {
+    std::vector<std::vector<double>> orig;
+    HighsInt dim_ns = basis.getinactive().size();
+    numberofreduces = 0;
+
+    orig.assign(dim_ns, std::vector<double>(dim_ns, 0.0));
+    resize(dim_ns);
+
+    Matrix temp(dim_ns, 0);
+
+    QpVector buffer_Qcol(runtime.instance.num_var);
+    QpVector buffer_ZtQi(dim_ns);
+    for (HighsInt i = 0; i < runtime.instance.num_var; i++) {
+      runtime.instance.Q.mat.extractcol(i, buffer_Qcol);
+      basis.Ztprod(buffer_Qcol, buffer_ZtQi);
+      temp.append(buffer_ZtQi);
+    }
+    MatrixBase& temp_t = temp.t();
+    for (HighsInt i = 0; i < dim_ns; i++) {
+      basis.Ztprod(temp_t.extractcol(i, buffer_Qcol), buffer_ZtQi);
+      for (HighsInt j = 0; j < buffer_ZtQi.num_nz; j++) {
+        orig[i][buffer_ZtQi.index[j]] = buffer_ZtQi.value[buffer_ZtQi.index[j]];
+      }
+    }
+
+    for (size_t col = 0; col < orig.size(); col++) {
+      for (size_t row = 0; row <= col; row++) {
+        double sum = 0;
+        if (row == col) {
+          for (size_t k = 0; k < row; k++)
+            sum += L[k * current_k_max + row] * L[k * current_k_max + row];
+          L[row * current_k_max + row] = sqrt(orig[row][row] - sum);
+        } else {
+          for (size_t k = 0; k < row; k++)
+            sum += (L[k * current_k_max + col] * L[k * current_k_max + row]);
+          L[row * current_k_max + col] =
+              (orig[col][row] - sum) / L[row * current_k_max + row];
+        }
+      }
+    }
+    current_k = dim_ns;
+    uptodate = true;
+  }
+
+  QpSolverStatus expand(const QpVector& yp, QpVector& gyp, QpVector& l, QpVector& m) {
+    if (!uptodate) {
+      return QpSolverStatus::OK;
+    }
+    double mu = gyp * yp;
+    l.resparsify();
+    double lambda = mu - l.norm2();
+    if (lambda > 0.0) {
+      if (current_k_max <= current_k + 1) {
+        resize(current_k_max * 2);
+      }
+
+      for (HighsInt i = 0; i < current_k; i++) {
+        L[i * current_k_max + current_k] = l.value[i];
+      }
+      L[current_k * current_k_max + current_k] = sqrt(lambda);
+
+      current_k++;
+    } else {
+      return QpSolverStatus::NOTPOSITIVDEFINITE;
+
+      //     |LL' 0|
+      // M = |0'  0| + bb' -aa'
+      // a = (k * m, alpha), b = (k * m, beta)
+      // b*b -a*a = mu
+      // k(b-a) = 1
+      // b + a = k*mu
+  // Commented out unreachable code
+      //      const double tolerance = 0.001;
+      //
+      //      double beta = max(tolerance, sqrt(m.norm2() / L[0] + fabs(mu)));
+      //      double k = 1 / (beta + sqrt(beta * beta - mu));
+      //      double alpha = k * mu - beta;
+      //
+      //      printf("k = %d, alpha = %lf, beta = %lf, k = %lf\n", (int)current_k, alpha,
+      //             beta, k);
+      //
+      //      a.clear();
+      //      a.resize(current_k + 1);
+      //      for (HighsInt i = 0; i < current_k; i++) {
+      //        a[i] = k * m.value[i];
+      //      }
+      //      a[current_k] = alpha;
+      //
+      //      std::vector<double> b(current_k + 1);
+      //      for (HighsInt i = 0; i < current_k; i++) {
+      //        b[i] = k * m.value[i];
+      //      }
+      //      b[current_k] = beta;
+      //
+      //      if (current_k_max <= current_k + 1) {
+      //        resize(current_k_max * 2);
+      //      }
+      //
+      //      // append b to the left of L
+      //      for (HighsInt row = current_k; row > 0; row--) {
+      //        // move row one position down
+      //        for (HighsInt i = 0; i < current_k; i++) {
+      //          L[row * current_k_max + i] = L[(row - 1) * current_k_max + i];
+      //        }
+      //      }
+      //      for (HighsInt i = 0; i < current_k + 1; i++) {
+      //        L[i] = b[i];
+      //      }
+      //
+      //      // re-triangulize
+      //      for (HighsInt i = 0; i < current_k + 1; i++) {
+      //        eliminate(L, i, i + 1, current_k_max, current_k + 1);
+      //      }
+      //
+      //      current_k = current_k + 1;
+    }
+    return QpSolverStatus::OK;
+  }
+
+  void solveL(QpVector& rhs) {
+    if (!uptodate) {
+      recompute();
+    }
+
+    if (current_k != rhs.dim) {
+      printf("dimension mismatch\n");
+      return;
+    }
+
+    for (HighsInt r = 0; r < rhs.dim; r++) {
+      for (HighsInt j = 0; j < r; j++) {
+        rhs.value[r] -= rhs.value[j] * L[j * current_k_max + r];
+      }
+
+      rhs.value[r] /= L[r * current_k_max + r];
+    }
+  }
+
+  // solve L' u = v
+  void solveLT(QpVector& rhs) {
+    for (HighsInt i = rhs.dim - 1; i >= 0; i--) {
+      double sum = 0.0;
+      for (HighsInt j = rhs.dim - 1; j > i; j--) {
+        sum += rhs.value[j] * L[i * current_k_max + j];
+      }
+      rhs.value[i] = (rhs.value[i] - sum) / L[i * current_k_max + i];
+    }
+  }
+
+  void solve(QpVector& rhs) {
+    if (!uptodate || (numberofreduces >= runtime.instance.num_var / 2 &&
+                      !has_negative_eigenvalue)) {
+      recompute();
+    }
+    solveL(rhs);
+    solveLT(rhs);
+
+    rhs.resparsify();
+  }
+
+  void eliminate(std::vector<double>& m, HighsInt i, HighsInt j, HighsInt kmax,
+                 HighsInt currentk) {
+    // i = col, j = row
+    if (m[j * kmax + i] == 0.0) {
+      return;
+    }
+    double z = sqrt(m[i * kmax + i] * m[i * kmax + i] +
+                    m[j * kmax + i] * m[j * kmax + i]);
+    double cos_, sin_;
+    if (z == 0) {
+      cos_ = 1.0;
+      sin_ = 0.0;
+    } else {
+      cos_ = m[i * kmax + i] / z;
+      sin_ = -m[j * kmax + i] / z;
+    }
+
+    if (sin_ == 0.0) {
+      if (cos_ > 0.0) {
+        // nothing
+      } else {
+        for (HighsInt k = 0; k < current_k; k++) {
+          // update entry i and j of column k
+          double a_ik = m[i * kmax + k];
+          // entry i
+          m[i * kmax + k] = -a_ik;
+          m[j * kmax + k] = -m[j * kmax + k];
+        }
+      }
+    } else if (cos_ == 0.0) {
+      if (sin_ > 0.0) {
+        for (HighsInt k = 0; k < current_k; k++) {
+          // update entry i and j of column k
+          double a_ik = m[i * kmax + k];
+          // entry i
+          m[i * kmax + k] = -m[j * kmax + k];
+          m[j * kmax + k] = a_ik;
+        }
+      } else {
+        for (HighsInt k = 0; k < current_k; k++) {
+          // update entry i and j of column k
+          double a_ik = m[i * kmax + k];
+          // entry i
+          m[i * kmax + k] = m[j * kmax + k];
+          m[j * kmax + k] = -a_ik;
+        }
+      }
+    } else {
+      // #pragma omp parallel for
+      for (HighsInt k = 0; k < current_k; k++) {
+        // update entry i and j of column k
+        double a_ik = m[i * kmax + k];
+        // entry i
+        m[i * kmax + k] = cos_ * a_ik - sin_ * m[j * kmax + k];
+        m[j * kmax + k] = sin_ * a_ik + cos_ * m[j * kmax + k];
+      }
+    }
+    m[j * kmax + i] = 0.0;
+  }
+
+  void reduce(const QpVector& buffer_d, const HighsInt maxabsd, bool p_in_v) {
+    if (current_k == 0) {
+      return;
+    }
+    if (!uptodate) {
+      return;
+    }
+    numberofreduces++;
+
+    unsigned p = maxabsd;  // col we push to the right and remove
+
+    // start situation: p=3, current_k = 5
+    // |1 x  | |x    |       |1   | |xxxxx|
+    // | 1x  | |xx   |  ===  | 1  | | xxxx|
+    // |  x1 | |xxx  |       |xxxx| |  xxx|
+    // |  x 1| |xxxx |       |  1 | |   xx|
+    //         |xxxxx|       |   1| |    x|
+    // next step: move row/col p to the bottom/right
+
+    //> save row p
+    std::vector<double> row_p(current_k, 0.0);
+    for (HighsInt i = 0; i < current_k; i++) {
+      row_p[i] = L[p * current_k_max + i];
+    }
+
+    //> move all rows > p up by one row
+    for (HighsInt row = p; row < current_k - 1; row++) {
+      for (HighsInt i = 0; i < current_k; i++) {
+        L[row * current_k_max + i] = L[(row + 1) * current_k_max + i];
+      }
+    }
+
+    //> load row p
+    for (HighsInt i = 0; i < current_k; i++) {
+      L[(current_k - 1) * current_k_max + i] = row_p[i];
+    }
+
+    //> now move col p to the right in each row
+    for (HighsInt row = 0; row < current_k; row++) {
+      double p_entry = L[row * current_k_max + p];
+      for (HighsInt col = p; col < current_k - 1; col++) {
+        L[row * current_k_max + col] = L[row * current_k_max + col + 1];
+      }
+      L[row * current_k_max + current_k - 1] = p_entry;
+    }
+
+    if (current_k == 1) {
+      current_k--;
+      return;
+    }
+
+    if (!p_in_v) {
+      // situation now:
+      // |1   x| |x    |       |1   | |xxxxx|
+      // | 1  x| |xx   |  ===  | 1  | | xxxx|
+      // |  1 x| |xxx x|       |  1 | |  xx |
+      // |   1x| |xxxxx|       |   1| |   x |
+      //         |xx  x|       |xxxx| |  xxx|
+      // next: remove nonzero entries in last column except for diagonal element
+      for (HighsInt r = (HighsInt)p - 1; r >= 0; r--) {  // to current_k-1
+        eliminate(L, current_k - 1, r, current_k_max, current_k);
+      }
+
+      // situation now:
+      // |1   x| |x   x|        |xxxx | |1   |
+      // | 1  x| |xx  x|  ===   | xxx | | 1  |
+      // |  1 x| |xxx x|        |  xx | |  1 |
+      // |   1x| |xxxxx|        |   x | |   1|
+      //         |    x|        |xxxxx| |xxxx|
+      // next: multiply product
+      // new last row: old last row (first current_k-1 elements) + r *
+      // R_current_k_current_k
+
+      for (HighsInt i = 0; i < buffer_d.num_nz; i++) {
+        HighsInt idx = buffer_d.index[i];
+        if (idx == maxabsd) {
+          continue;
+        }
+        if (idx < maxabsd) {
+          L[(current_k - 1) * current_k_max + idx] +=
+              -buffer_d.value[idx] / buffer_d.value[maxabsd] *
+              L[(current_k - 1) * current_k_max + current_k - 1];
+        } else {
+          L[(current_k - 1) * current_k_max + idx - 1] +=
+              -buffer_d.value[idx] / buffer_d.value[maxabsd] *
+              L[(current_k - 1) * current_k_max + current_k - 1];
+        }
+      }
+      // situation now: as above, but no more product
+    }
+    // next: eliminate last row
+    for (HighsInt i = 0; i < current_k - 1; i++) {
+      eliminate(L, i, current_k - 1, current_k_max, current_k);
+    }
+    current_k--;
+  }
+
+  void report(std::string name = "") {
+    printf("%s\n", name.c_str());
+    for (HighsInt i = 0; i < current_k; i++) {
+      for (HighsInt j = 0; j < current_k; j++) {
+        printf("%lf ", L[i * current_k_max + j]);
+      }
+      printf("\n");
+    }
+  }
+
+  double density() {
+    if (current_k == 0) {
+      return 0.0;
+    }
+
+    HighsInt num_nz = 0;
+    for (HighsInt i = 0; i < current_k; i++) {
+      for (HighsInt j = 0; j < current_k; j++) {
+        if (fabs(L[i * current_k_max + j]) > 1e-7) {
+          num_nz++;
+        }
+      }
+    }
+    return (double)num_nz / (current_k * (current_k + 1) / 2.0);
+  }
+};
+
+#endif

casadi/include/highs/qpsolver/feasibility_bounded.hpp

@@ -0,0 +1,105 @@
+#ifndef __SRC_LIB_FEASIBILITYBOUNDED_HPP__
+#define __SRC_LIB_FEASIBILITYBOUNDED_HPP__
+
+#include "Highs.h"
+#include "qpsolver/a_asm.hpp"
+#include "qpsolver/crashsolution.hpp"
+
+static void computeStartingPointBounded(Instance& instance,
+					Settings& settings,
+					Statistics& stats,
+					QpModelStatus& modelstatus,
+					QpHotstartInformation& result,
+					HighsTimer& timer) {
+  // compute initial feasible point for problems with bounds only (no general linear constraints)
+
+  // compute  Qx + c = 0 --> x = Q^-1c
+  std::vector<double> L;
+  L.resize(instance.num_var * instance.num_var);
+
+  // compute cholesky factorization of Q
+  for (size_t col = 0; col < (size_t)instance.num_var; col++) {
+    for (size_t idx = instance.Q.mat.start[col]; idx < (size_t)instance.Q.mat.start[col+1]; idx++) {
+      double sum = 0;
+      size_t row = instance.Q.mat.index[idx]; 
+      if (row == col) {
+        for (size_t k = 0; k < row; k++)
+          sum += L[k * instance.num_var + row] * L[k * instance.num_var + row];
+        L[row * instance.num_var + row] = sqrt(instance.Q.mat.value[idx] - sum);
+      } else {
+        for (size_t k = 0; k < row; k++)
+          sum += (L[k * instance.num_var + col] * L[k * instance.num_var + row]);
+        L[row * instance.num_var + col] =
+            (instance.Q.mat.value[idx] - sum) / L[row * instance.num_var + row];
+      }
+    }
+  }
+
+  // solve for c
+  QpVector res = -instance.c;
+  for (HighsInt r = 0; r <res.dim; r++) {
+    for (HighsInt j = 0; j < r; j++) {
+      res.value[r] -= res.value[j] * L[j * instance.num_var + r];
+    }
+    res.value[r] /= L[r * instance.num_var + r];
+  }
+
+  for (HighsInt i = res.dim - 1; i >= 0; i--) {
+    double sum = 0.0;
+    for (HighsInt j = res.dim - 1; j > i; j--) {
+      sum += res.value[j] * L[i * instance.num_var + j];
+    }
+    res.value[i] = (res.value[i] - sum) / L[i * instance.num_var + i];
+  }
+
+  // project solution to bounds and collect active bounds
+  QpVector x0(instance.num_var);
+  QpVector ra(instance.num_con);
+  std::vector<HighsInt> initialactive;
+  std::vector<HighsInt> initialinactive;
+  std::vector<BasisStatus> atlower;
+
+  for (int i=0; i<instance.num_var; i++) {
+    if (res.value[i] > 0.5/settings.hessianregularizationfactor 
+        && instance.var_up[i] == std::numeric_limits<double>::infinity()
+        && instance.c.value[i] < 0.0) {
+          modelstatus = QpModelStatus::kUnbounded;
+          return;
+    } else if (res.value[i] < 0.5/settings.hessianregularizationfactor 
+        && instance.var_lo[i] == std::numeric_limits<double>::infinity()
+        && instance.c.value[i] > 0.0) {
+          modelstatus = QpModelStatus::kUnbounded;
+          return;
+    } else if (res.value[i] <= instance.var_lo[i]) {
+        res.value[i] = instance.var_lo[i];
+        initialactive.push_back(i + instance.num_con);
+        atlower.push_back(BasisStatus::kActiveAtLower);
+    } else if (res.value[i] >= instance.var_up[i]) {
+        res.value[i] = instance.var_up[i];
+        initialactive.push_back(i + instance.num_con);
+        atlower.push_back(BasisStatus::kActiveAtUpper);
+    } else {
+        initialinactive.push_back(i + instance.num_con);
+    }
+    if (fabs(res.value[i]) > 1e-4) {
+      x0.value[i] = res.value[i];
+      x0.index[x0.num_nz++] = i;
+    }
+  }
+
+  // if no bounds are active, solution lies in the interior -> optimal
+  if (initialactive.size() == 0) {
+    modelstatus = QpModelStatus::kOptimal;
+  }
+
+  assert((HighsInt)(initialactive.size() + initialinactive.size()) ==
+         instance.num_var);
+
+  result.status = atlower;
+  result.active = initialactive;
+  result.inactive = initialinactive;
+  result.primal = x0;
+  result.rowact = ra;
+}
+
+#endif