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

casadi/include/highs/presolve/HighsPostsolveStack.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -16,6 +16,7 @@
 #ifndef PRESOLVE_HIGHS_POSTSOLVE_STACK_H_
 #define PRESOLVE_HIGHS_POSTSOLVE_STACK_H_
 
+#include <algorithm>
 #include <cassert>
 #include <cmath>
 #include <numeric>
@@ -104,6 +105,7 @@ class HighsPostsolveStack {
     HighsInt col;
     bool lowerTightened;
     bool upperTightened;
+    RowType rowType;
 
     void undo(const HighsOptions& options,
               const std::vector<Nonzero>& colValues, HighsSolution& solution,
@@ -173,6 +175,7 @@ class HighsPostsolveStack {
     double colBound;
     HighsInt col;
     bool atInfiniteUpper;
+    bool colIntegral;
 
     void undo(const HighsOptions& options,
               const std::vector<Nonzero>& colValues, HighsSolution& solution,
@@ -234,7 +237,7 @@ class HighsPostsolveStack {
   };
 
   HighsDataStack reductionValues;
-  std::vector<std::pair<ReductionType, HighsInt>> reductions;
+  std::vector<std::pair<ReductionType, size_t>> reductions;
   std::vector<HighsInt> origColIndex;
   std::vector<HighsInt> origRowIndex;
   std::vector<uint8_t> linearlyTransformable;
@@ -245,11 +248,15 @@ class HighsPostsolveStack {
   HighsInt origNumRow = -1;
 
   void reductionAdded(ReductionType type) {
-    HighsInt position = reductionValues.getCurrentDataSize();
+    size_t position = reductionValues.getCurrentDataSize();
     reductions.emplace_back(type, position);
   }
 
  public:
+  const HighsInt* getOrigRowsIndex() const { return origRowIndex.data(); }
+
+  const HighsInt* getOrigColsIndex() const { return origColIndex.data(); }
+
   HighsInt getOrigRowIndex(HighsInt row) const {
     assert(row < (HighsInt)origRowIndex.size());
     return origRowIndex[row];
@@ -261,19 +268,19 @@ class HighsPostsolveStack {
   }
 
   void appendCutsToModel(HighsInt numCuts) {
-    HighsInt currNumRow = origRowIndex.size();
-    HighsInt newNumRow = currNumRow + numCuts;
+    size_t currNumRow = origRowIndex.size();
+    size_t newNumRow = currNumRow + numCuts;
     origRowIndex.resize(newNumRow);
-    for (HighsInt i = currNumRow; i != newNumRow; ++i)
+    for (size_t i = currNumRow; i != newNumRow; ++i)
       origRowIndex[i] = origNumRow++;
   }
 
   void removeCutsFromModel(HighsInt numCuts) {
     origNumRow -= numCuts;
 
-    HighsInt origRowIndexSize = origRowIndex.size();
-    for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i) {
-      if (origRowIndex[i] < origNumRow) break;
+    size_t origRowIndexSize = origRowIndex.size();
+    for (size_t i = origRowIndex.size(); i > 0; --i) {
+      if (origRowIndex[i - 1] < origNumRow) break;
       --origRowIndexSize;
     }
 
@@ -321,6 +328,7 @@ class HighsPostsolveStack {
                          double coefSubst, double coef, double rhs,
                          double substLower, double substUpper, double substCost,
                          bool lowerTightened, bool upperTightened,
+                         RowType rowType,
                          const HighsMatrixSlice<ColStorageFormat>& colVec) {
     colValues.clear();
     for (const HighsSliceNonzero& colVal : colVec)
@@ -329,7 +337,7 @@ class HighsPostsolveStack {
     reductionValues.push(DoubletonEquation{
         coef, coefSubst, rhs, substLower, substUpper, substCost,
         row == -1 ? -1 : origRowIndex[row], origColIndex[colSubst],
-        origColIndex[col], lowerTightened, upperTightened});
+        origColIndex[col], lowerTightened, upperTightened, rowType});
     reductionValues.push(colValues);
     reductionAdded(ReductionType::kDoubletonEquation);
   }
@@ -445,13 +453,14 @@ class HighsPostsolveStack {
   template <typename ColStorageFormat>
   void forcingColumn(HighsInt col,
                      const HighsMatrixSlice<ColStorageFormat>& colVec,
-                     double cost, double boundVal, bool atInfiniteUpper) {
+                     double cost, double boundVal, bool atInfiniteUpper,
+                     bool colIntegral) {
     colValues.clear();
     for (const HighsSliceNonzero& colVal : colVec)
       colValues.emplace_back(origRowIndex[colVal.index()], colVal.value());
 
-    reductionValues.push(
-        ForcingColumn{cost, boundVal, origColIndex[col], atInfiniteUpper});
+    reductionValues.push(ForcingColumn{cost, boundVal, origColIndex[col],
+                                       atInfiniteUpper, colIntegral});
     reductionValues.push(colValues);
     reductionAdded(ReductionType::kForcingColumn);
   }
@@ -511,7 +520,7 @@ class HighsPostsolveStack {
       const std::vector<double>& origPrimalSolution) {
     std::vector<double> reducedSolution = origPrimalSolution;
 
-    for (const std::pair<ReductionType, HighsInt>& primalColTransformation :
+    for (const std::pair<ReductionType, size_t>& primalColTransformation :
          reductions) {
       switch (primalColTransformation.first) {
         case ReductionType::kDuplicateColumn: {
@@ -533,8 +542,8 @@ class HighsPostsolveStack {
       }
     }
 
-    HighsInt reducedNumCol = origColIndex.size();
-    for (HighsInt i = 0; i < reducedNumCol; ++i)
+    size_t reducedNumCol = origColIndex.size();
+    for (size_t i = 0; i < reducedNumCol; ++i)
       reducedSolution[i] = reducedSolution[origColIndex[i]];
 
     reducedSolution.resize(reducedNumCol);
@@ -542,7 +551,36 @@ class HighsPostsolveStack {
   }
 
   bool isColLinearlyTransformable(HighsInt col) const {
-    return linearlyTransformable[col];
+    return (linearlyTransformable[col] != 0);
+  }
+
+  template <typename T>
+  void undoIterateBackwards(std::vector<T>& values,
+                            const std::vector<HighsInt>& index,
+                            HighsInt origSize) {
+    values.resize(origSize);
+#ifdef DEBUG_EXTRA
+    // Fill vector with NaN for debugging purposes
+    std::vector<T> valuesNew;
+    valuesNew.resize(origSize, std::numeric_limits<T>::signaling_NaN());
+    for (size_t i = index.size(); i > 0; --i) {
+      assert(static_cast<size_t>(index[i - 1]) >= i - 1);
+      valuesNew[index[i - 1]] = values[i - 1];
+    }
+    std::copy(valuesNew.cbegin(), valuesNew.cend(), values.begin());
+#else
+    for (size_t i = index.size(); i > 0; --i) {
+      assert(static_cast<size_t>(index[i - 1]) >= i - 1);
+      values[index[i - 1]] = values[i - 1];
+    }
+#endif
+  }
+
+  /// check if vector contains NaN or Inf
+  bool containsNanOrInf(const std::vector<double>& v) const {
+    return std::find_if(v.cbegin(), v.cend(), [](const double& d) {
+             return (std::isnan(d) || std::isinf(d));
+           }) != v.cend();
   }
 
   /// undo presolve steps for primal dual solution and basis
@@ -557,49 +595,33 @@ class HighsPostsolveStack {
 
     // expand solution to original index space
     assert(origNumCol > 0);
-    solution.col_value.resize(origNumCol);
-    for (HighsInt i = origColIndex.size() - 1; i >= 0; --i) {
-      assert(origColIndex[i] >= i);
-      solution.col_value[origColIndex[i]] = solution.col_value[i];
-    }
+    undoIterateBackwards(solution.col_value, origColIndex, origNumCol);
 
     assert(origNumRow >= 0);
-    solution.row_value.resize(origNumRow);
-    for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i) {
-      assert(origRowIndex[i] >= i);
-      solution.row_value[origRowIndex[i]] = solution.row_value[i];
-    }
+    undoIterateBackwards(solution.row_value, origRowIndex, origNumRow);
 
     if (perform_dual_postsolve) {
       // if dual solution is given, expand dual solution and basis to original
       // index space
-      solution.col_dual.resize(origNumCol);
-      for (HighsInt i = origColIndex.size() - 1; i >= 0; --i)
-        solution.col_dual[origColIndex[i]] = solution.col_dual[i];
+      undoIterateBackwards(solution.col_dual, origColIndex, origNumCol);
 
-      solution.row_dual.resize(origNumRow);
-      for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i)
-        solution.row_dual[origRowIndex[i]] = solution.row_dual[i];
+      undoIterateBackwards(solution.row_dual, origRowIndex, origNumRow);
     }
 
     if (perform_basis_postsolve) {
       // if basis is given, expand basis status values to original index space
-      basis.col_status.resize(origNumCol);
-      for (HighsInt i = origColIndex.size() - 1; i >= 0; --i)
-        basis.col_status[origColIndex[i]] = basis.col_status[i];
+      undoIterateBackwards(basis.col_status, origColIndex, origNumCol);
 
-      basis.row_status.resize(origNumRow);
-      for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i)
-        basis.row_status[origRowIndex[i]] = basis.row_status[i];
+      undoIterateBackwards(basis.row_status, origRowIndex, origNumRow);
     }
 
     // now undo the changes
-    for (HighsInt i = reductions.size() - 1; i >= 0; --i) {
+    for (size_t i = reductions.size(); i > 0; --i) {
       if (report_col >= 0)
         printf("Before  reduction %2d (type %2d): col_value[%2d] = %g\n",
-               int(i), int(reductions[i].first), int(report_col),
+               int(i - 1), int(reductions[i - 1].first), int(report_col),
                solution.col_value[report_col]);
-      switch (reductions[i].first) {
+      switch (reductions[i - 1].first) {
         case ReductionType::kLinearTransform: {
           LinearTransform reduction;
           reductionValues.pop(reduction);
@@ -689,13 +711,23 @@ class HighsPostsolveStack {
           break;
         }
         default:
-          printf("Reduction case %d not handled\n", int(reductions[i].first));
+          printf("Reduction case %d not handled\n",
+                 int(reductions[i - 1].first));
           if (kAllowDeveloperAssert) assert(1 == 0);
       }
     }
     if (report_col >= 0)
       printf("After last reduction: col_value[%2d] = %g\n", int(report_col),
              solution.col_value[report_col]);
+
+#ifdef DEBUG_EXTRA
+    // solution should not contain NaN or Inf
+    assert(!containsNanOrInf(solution.col_value));
+    // row values are not determined by postsolve
+    // assert(!containsNanOrInf(solution.row_value));
+    assert(!containsNanOrInf(solution.col_dual));
+    assert(!containsNanOrInf(solution.row_dual));
+#endif
   }
 
   /// undo presolve steps for primal solution
@@ -727,7 +759,7 @@ class HighsPostsolveStack {
   void undoUntil(const HighsOptions& options,
                  const std::vector<HighsInt>& flagRow,
                  const std::vector<HighsInt>& flagCol, HighsSolution& solution,
-                 HighsBasis& basis, HighsInt numReductions) {
+                 HighsBasis& basis, size_t numReductions) {
     reductionValues.resetPosition();
 
     // Do these returns ever happen? How is it known that undo has not
@@ -746,44 +778,28 @@ class HighsPostsolveStack {
     bool perform_basis_postsolve = basis.valid;
 
     // expand solution to original index space
-    solution.col_value.resize(origNumCol);
-    for (HighsInt i = origColIndex.size() - 1; i >= 0; --i) {
-      assert(origColIndex[i] >= i);
-      solution.col_value[origColIndex[i]] = solution.col_value[i];
-    }
+    undoIterateBackwards(solution.col_value, origColIndex, origNumCol);
 
-    solution.row_value.resize(origNumRow);
-    for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i) {
-      assert(origRowIndex[i] >= i);
-      solution.row_value[origRowIndex[i]] = solution.row_value[i];
-    }
+    undoIterateBackwards(solution.row_value, origRowIndex, origNumRow);
 
     if (perform_dual_postsolve) {
       // if dual solution is given, expand dual solution and basis to original
       // index space
-      solution.col_dual.resize(origNumCol);
-      for (HighsInt i = origColIndex.size() - 1; i >= 0; --i)
-        solution.col_dual[origColIndex[i]] = solution.col_dual[i];
+      undoIterateBackwards(solution.col_dual, origColIndex, origNumCol);
 
-      solution.row_dual.resize(origNumRow);
-      for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i)
-        solution.row_dual[origRowIndex[i]] = solution.row_dual[i];
+      undoIterateBackwards(solution.row_dual, origRowIndex, origNumRow);
     }
 
     if (perform_basis_postsolve) {
       // if basis is given, expand basis status values to original index space
-      basis.col_status.resize(origNumCol);
-      for (HighsInt i = origColIndex.size() - 1; i >= 0; --i)
-        basis.col_status[origColIndex[i]] = basis.col_status[i];
+      undoIterateBackwards(basis.col_status, origColIndex, origNumCol);
 
-      basis.row_status.resize(origNumRow);
-      for (HighsInt i = origRowIndex.size() - 1; i >= 0; --i)
-        basis.row_status[origRowIndex[i]] = basis.row_status[i];
+      undoIterateBackwards(basis.row_status, origRowIndex, origNumRow);
     }
 
     // now undo the changes
-    for (HighsInt i = reductions.size() - 1; i >= numReductions; --i) {
-      switch (reductions[i].first) {
+    for (size_t i = reductions.size(); i > numReductions; --i) {
+      switch (reductions[i - 1].first) {
         case ReductionType::kLinearTransform: {
           LinearTransform reduction;
           reductionValues.pop(reduction);
@@ -873,6 +889,14 @@ class HighsPostsolveStack {
         }
       }
     }
+#ifdef DEBUG_EXTRA
+    // solution should not contain NaN or Inf
+    assert(!containsNanOrInf(solution.col_value));
+    // row values are not determined by postsolve
+    // assert(!containsNanOrInf(solution.row_value));
+    assert(!containsNanOrInf(solution.col_dual));
+    assert(!containsNanOrInf(solution.row_dual));
+#endif
   }
 
   size_t numReductions() const { return reductions.size(); }

casadi/include/highs/presolve/HighsSymmetry.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -25,7 +25,7 @@
 #include "util/HighsHash.h"
 #include "util/HighsInt.h"
 
-/// class that is responsible for assiging distinct colors for each distinct
+/// class that is responsible for assigning distinct colors for each distinct
 /// double value
 class HighsMatrixColoring {
   using u32 = std::uint32_t;
@@ -44,7 +44,6 @@ class HighsMatrixColoring {
     // iterator points to smallest element in map which fulfills key >= value -
     // tolerance
     auto it = colorMap.lower_bound(value - tolerance);
-    u32 color;
     // check if there is no such element, or if this element has a key value +
     // tolerance in which case we create a new color and store it with the key
     // value
@@ -80,10 +79,12 @@ struct HighsOrbitopeMatrix {
   std::vector<int8_t> rowIsSetPacking;
   std::vector<HighsInt> matrix;
 
-  HighsInt& entry(HighsInt i, HighsInt j) { return matrix[i + j * numRows]; }
+  HighsInt& entry(HighsInt i, HighsInt j) {
+    return matrix[i + static_cast<size_t>(j) * numRows];
+  }
 
   const HighsInt& entry(HighsInt i, HighsInt j) const {
-    return matrix[i + j * numRows];
+    return matrix[i + static_cast<size_t>(j) * numRows];
   }
 
   HighsInt& operator()(HighsInt i, HighsInt j) { return entry(i, j); }

casadi/include/highs/presolve/ICrash.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */
@@ -85,7 +85,13 @@ struct Quadratic {
   double mu;
   std::vector<double> lambda;
 
-  Quadratic(HighsLp lp_, ICrashOptions options_) : lp(lp_), options(options_) {}
+  Quadratic(HighsLp lp_, ICrashOptions options_)
+      : lp(lp_),
+        options(options_),
+        lp_objective(0.0),
+        quadratic_objective(0.0),
+        residual_norm_2(0.0),
+        mu(0.0) {}
 };
 
 // Functions: Call.

casadi/include/highs/presolve/ICrashUtil.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/presolve/ICrashX.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/presolve/PresolveComponent.h

@@ -2,7 +2,7 @@
 /*                                                                       */
 /*    This file is part of the HiGHS linear optimization suite           */
 /*                                                                       */
-/*    Written and engineered 2008-2023 by Julian Hall, Ivet Galabova,    */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
 /*    Leona Gottwald and Michael Feldmeier                               */
 /*                                                                       */
 /*    Available as open-source under the MIT License                     */

casadi/include/highs/qpsolver/a_asm.hpp

@@ -8,22 +8,24 @@
 #include "util/HighsTimer.h"
 
 enum class QpAsmStatus {
-  OK,
-  NEGATIVEEIGENVALUEINREDUCEDHESSIAN,
-  BASISRANKDEFICIENT
+  kOk,
+  kWarning,
+  kError
+  //  NEGATIVEEIGENVALUEINREDUCEDHESSIAN,
+  //  BASISRANKDEFICIENT
 };
 
 struct QpSolution {
-  Vector primal;
-  Vector rowactivity;
-  Vector dualvar;
-  Vector dualcon;
+  QpVector primal;
+  QpVector rowactivity;
+  QpVector dualvar;
+  QpVector dualcon;
 
   std::vector<BasisStatus> status_var;
   std::vector<BasisStatus> status_con;
 
-  QpSolution(Instance& instance) : primal(Vector(instance.num_var)),
-        rowactivity(Vector(instance.num_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),
@@ -35,11 +37,11 @@ struct QpHotstartInformation {
   std::vector<HighsInt> active;
   std::vector<HighsInt> inactive;
   std::vector<BasisStatus> status;
-  Vector primal;
-  Vector rowact;
+  QpVector primal;
+  QpVector rowact;
 
   QpHotstartInformation(HighsInt num_var, HighsInt num_row)
-      : primal(Vector(num_var)), rowact(Vector(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.
@@ -50,7 +52,16 @@ struct QpHotstartInformation {
 // 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

casadi/include/highs/qpsolver/a_quass.hpp

@@ -1,12 +1,19 @@
 #ifndef __SRC_LIB_QPSOLVER_QUASS_HPP__
 #define __SRC_LIB_QPSOLVER_QUASS_HPP__
 
+#include "Highs.h"
 #include "qpsolver/instance.hpp"
 #include "qpsolver/qpconst.hpp"
 #include "qpsolver/a_asm.hpp"
 #include "qpsolver/settings.hpp"
 
 
-QpAsmStatus solveqp(Instance& instance, Settings& settings, Statistics& stats, QpModelStatus& modelstatus, QpSolution& solution, HighsTimer& qp_timer);
+QpAsmStatus solveqp(Instance& instance,
+		    Settings& settings,
+		    Statistics& stats,
+		    HighsModelStatus& highs_model_status,
+		    HighsBasis& highs_basis,
+		    HighsSolution& highs_solution, 
+		    HighsTimer& timer);
 
 #endif

casadi/include/highs/qpsolver/basis.hpp

@@ -0,0 +1,150 @@
+#pragma once
+#ifndef __SRC_LIB_BASIS_HPP__
+#define __SRC_LIB_BASIS_HPP__
+
+#include <map>
+#include <vector>
+
+#include "qpsolver/instance.hpp"
+#include "qpsolver/pricing.hpp"
+#include "qpsolver/qpconst.hpp"
+#include "qpsolver/runtime.hpp"
+#include "qpsolver/snippets.hpp"
+#include "util/HFactor.h"
+#include "util/HVector.h"
+#include "util/HVectorBase.h"
+
+class Basis {
+  HVector buffer_vec2hvec;
+  QpVector Ztprod_res;
+  QpVector buffer_Zprod;
+
+  HVector& vec2hvec(const QpVector& vec) {
+    buffer_vec2hvec.clear();
+    for (HighsInt i = 0; i < vec.num_nz; i++) {
+      buffer_vec2hvec.index[i] = vec.index[i];
+      buffer_vec2hvec.array[vec.index[i]] = vec.value[vec.index[i]];
+    }
+    buffer_vec2hvec.count = vec.num_nz;
+    buffer_vec2hvec.packFlag = true;
+    return buffer_vec2hvec;
+  }
+
+  QpVector& hvec2vec(const HVector& hvec, QpVector& target) {
+    target.reset();
+    for (HighsInt i = 0; i < hvec.count; i++) {
+      target.index[i] = hvec.index[i];
+      target.value[target.index[i]] = hvec.array[hvec.index[i]];
+    }
+    // for (HighsInt i = 0; i < hvec.size; i++) {
+    //   target.index[i] = hvec.index[i];
+    //   target.value[i] = hvec.array[i];
+    // }
+    target.num_nz = hvec.count;
+    return target;
+  }
+
+  QpVector hvec2vec(const HVector& hvec) {
+    QpVector vec(hvec.size);
+
+    return hvec2vec(hvec, vec);
+  }
+
+  Runtime& runtime;
+  HFactor basisfactor;
+  HighsInt updatessinceinvert = 0;
+
+  MatrixBase Atran;
+
+  // indices of active constraints in basis
+  std::vector<HighsInt> active_constraint_index;
+
+  // ids of constraints that are in the basis but not active
+  // I need to extract those columns to get Z
+  std::vector<HighsInt> non_active_constraint_index;
+
+  // ids of constraints that are in the basis
+  std::vector<HighsInt> baseindex;
+
+  std::map<int, BasisStatus> basisstatus;
+
+  // index i: -1 if constraint not in basis, [0, num_var] if
+  // constraint in basis (active or not)
+  std::vector<HighsInt> constraintindexinbasisfactor;
+
+  void build();
+
+  // buffer to avoid recreating vectors
+  QpVector buffer_column_aq;
+  QpVector buffer_row_ep;
+
+  // buffers to prevent multiple btran/ftran
+  HighsInt buffered_q = -1;
+  HighsInt buffered_p = -1;
+  HVector row_ep;
+  HVector col_aq;
+
+  bool reinversion_hint = false;
+ public:
+
+
+  Basis(Runtime& rt, std::vector<HighsInt> active,
+        std::vector<BasisStatus> atlower, std::vector<HighsInt> inactive);
+
+  bool getreinversionhint() { return reinversion_hint; }
+
+  void rebuild();
+
+  HighsInt getnupdatessinceinvert() { return updatessinceinvert; }
+
+  HighsInt getnumactive() const { return active_constraint_index.size(); };
+
+  HighsInt getnuminactive() const { return non_active_constraint_index.size(); };
+
+  const std::vector<HighsInt>& getactive() const {
+    return active_constraint_index;
+  };
+
+  const std::vector<HighsInt>& getinactive() const {
+    return non_active_constraint_index;
+  };
+
+  const std::vector<HighsInt>& getindexinfactor() const {
+    return constraintindexinbasisfactor;
+  };
+
+  BasisStatus getstatus(HighsInt conid) { return basisstatus[conid]; };
+
+  void report();
+
+  // move that constraint into V section basis (will correspond to
+  // Nullspace from now on)
+  void deactivate(HighsInt conid);
+
+  QpSolverStatus activate(const Settings& settings, HighsInt conid, BasisStatus atlower,
+                          HighsInt nonactivetoremove, Pricing* pricing);
+
+  void updatebasis(const Settings& settings, HighsInt newactivecon, HighsInt droppedcon,
+                   Pricing* pricing);
+
+  QpVector btran(const QpVector& rhs, bool buffer = false, HighsInt p = -1);
+
+  QpVector ftran(const QpVector& rhs, bool buffer = false, HighsInt q = -1);
+
+  QpVector& btran(const QpVector& rhs, QpVector& target, bool buffer = false,
+                HighsInt p = -1);
+
+  QpVector& ftran(const QpVector& rhs, QpVector& target, bool buffer = false,
+                HighsInt q = -1);
+
+  QpVector recomputex(const Instance& inst);
+
+  void write(std::string filename);
+
+  QpVector& Ztprod(const QpVector& rhs, QpVector& target, bool buffer = false,
+                 HighsInt q = -1);
+
+  QpVector& Zprod(const QpVector& rhs, QpVector& target);
+};
+
+#endif

casadi/include/highs/qpsolver/crashsolution.hpp

@@ -0,0 +1,12 @@
+#ifndef __SRC_LIB_CRASHSOLUTION_HPP__
+#define __SRC_LIB_CRASHSOLUTION_HPP__
+
+#include <cstdlib>
+#include "runtime.hpp"
+
+inline
+bool isfreevar(Instance& instance, HighsInt idx) {
+  return instance.var_lo[idx] == -std::numeric_limits<double>::infinity() && instance.var_up[idx] == std::numeric_limits<double>::infinity();
+}
+
+#endif