casadi 3.6.7__cp313-none-macosx_10_13_x86_64.macosx_10_13_intel.whl

casadi/include/highs/presolve/HighsSymmetry.h

@@ -0,0 +1,284 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file HighsSymmetry.h
+ * @brief Facilities for symmetry detection
+ * @author Leona Gottwald
+ */
+
+#ifndef PRESOLVE_HIGHS_SYMMETRY_H_
+#define PRESOLVE_HIGHS_SYMMETRY_H_
+
+#include <algorithm>
+#include <map>
+#include <vector>
+
+#include "lp_data/HighsLp.h"
+#include "util/HighsDisjointSets.h"
+#include "util/HighsHash.h"
+#include "util/HighsInt.h"
+
+/// class that is responsible for assigning distinct colors for each distinct
+/// double value
+class HighsMatrixColoring {
+  using u32 = std::uint32_t;
+
+  std::map<double, u32> colorMap;
+  double tolerance;
+
+ public:
+  // initialize with exact 0.0 and 1.0, to not have differing results due tiny
+  // numerical differences on those values
+  HighsMatrixColoring(double tolerance)
+      : colorMap({{0.0, 1}, {1.0, 2}, {-kHighsInf, 3}, {kHighsInf, 4}}),
+        tolerance(tolerance) {}
+
+  u32 color(double value) {
+    // iterator points to smallest element in map which fulfills key >= value -
+    // tolerance
+    auto it = colorMap.lower_bound(value - tolerance);
+    // 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
+    if (it == colorMap.end() || it->first > value + tolerance)
+      it = colorMap.emplace_hint(it, value, colorMap.size() + 1);
+    return it->second;
+  }
+};
+
+class HighsDomain;
+class HighsCliqueTable;
+struct HighsSymmetries;
+struct StabilizerOrbits {
+  std::vector<HighsInt> orbitCols;
+  std::vector<HighsInt> orbitStarts;
+  std::vector<HighsInt> stabilizedCols;
+  const HighsSymmetries* symmetries;
+
+  HighsInt orbitalFixing(HighsDomain& domain) const;
+
+  bool isStabilized(HighsInt col) const;
+};
+
+struct HighsOrbitopeMatrix {
+  enum Type {
+    kFull,
+    kPacking,
+  };
+  HighsInt rowLength;
+  HighsInt numRows;
+  HighsInt numSetPackingRows;
+  HighsHashTable<HighsInt, HighsInt> columnToRow;
+  std::vector<int8_t> rowIsSetPacking;
+  std::vector<HighsInt> matrix;
+
+  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 + static_cast<size_t>(j) * numRows];
+  }
+
+  HighsInt& operator()(HighsInt i, HighsInt j) { return entry(i, j); }
+
+  const HighsInt& operator()(HighsInt i, HighsInt j) const {
+    return entry(i, j);
+  }
+
+  HighsInt orbitalFixing(HighsDomain& domain) const;
+
+  void determineOrbitopeType(HighsCliqueTable& cliquetable);
+
+  HighsInt getBranchingColumn(const std::vector<double>& colLower,
+                              const std::vector<double>& colUpper,
+                              HighsInt col) const;
+
+ private:
+  HighsInt orbitalFixingForFullOrbitope(const std::vector<HighsInt>& rows,
+                                        HighsDomain& domain) const;
+
+  HighsInt orbitalFixingForPackingOrbitope(const std::vector<HighsInt>& rows,
+                                           HighsDomain& domain) const;
+};
+
+struct HighsSymmetries {
+  std::vector<HighsInt> permutationColumns;
+  std::vector<HighsInt> permutations;
+  std::vector<HighsInt> orbitPartition;
+  std::vector<HighsInt> orbitSize;
+  std::vector<HighsInt> columnPosition;
+  std::vector<HighsInt> linkCompressionStack;
+  std::vector<HighsOrbitopeMatrix> orbitopes;
+  HighsHashTable<HighsInt, HighsInt> columnToOrbitope;
+  HighsInt numPerms = 0;
+  HighsInt numGenerators = 0;
+
+  void clear();
+  void mergeOrbits(HighsInt col1, HighsInt col2);
+  HighsInt getOrbit(HighsInt col);
+
+  HighsInt propagateOrbitopes(HighsDomain& domain) const;
+
+  HighsInt getBranchingColumn(const std::vector<double>& colLower,
+                              const std::vector<double>& colUpper,
+                              HighsInt col) const {
+    if (columnToOrbitope.size() == 0) return col;
+    const HighsInt* orbitope = columnToOrbitope.find(col);
+    if (!orbitope || orbitopes[*orbitope].numSetPackingRows == 0) return col;
+
+    return orbitopes[*orbitope].getBranchingColumn(colLower, colUpper, col);
+  }
+
+  std::shared_ptr<const StabilizerOrbits> computeStabilizerOrbits(
+      const HighsDomain& localdom);
+};
+
+class HighsSymmetryDetection {
+  using u64 = std::uint64_t;
+  using u32 = std::uint32_t;
+
+  const HighsLp* model;
+  // compressed graph storage
+  std::vector<HighsInt> Gstart;
+  std::vector<HighsInt> Gend;
+  std::vector<std::pair<HighsInt, HighsUInt>> Gedge;
+
+  std::vector<std::pair<HighsInt, HighsUInt>> edgeBuffer;
+
+  std::vector<HighsInt> currentPartition;
+  std::vector<HighsInt> currentPartitionLinks;
+  std::vector<HighsInt> vertexToCell;
+  std::vector<HighsInt> vertexPosition;
+  std::vector<HighsInt> vertexGroundSet;
+  std::vector<HighsInt> orbitPartition;
+  std::vector<HighsInt> orbitSize;
+
+  std::vector<HighsInt> cellCreationStack;
+  std::vector<std::uint8_t> cellInRefinementQueue;
+  std::vector<HighsInt> refinementQueue;
+  std::vector<HighsInt*> distinguishCands;
+  std::vector<HighsInt> automorphisms;
+
+  std::vector<HighsInt> linkCompressionStack;
+
+  std::vector<u32> currNodeCertificate;
+  std::vector<u32> firstLeaveCertificate;
+  std::vector<u32> bestLeaveCertificate;
+  std::vector<HighsInt> firstLeavePartition;
+  std::vector<HighsInt> bestLeavePartition;
+
+  HighsHashTable<HighsInt, u32> vertexHash;
+  HighsHashTable<std::tuple<HighsInt, HighsInt, HighsUInt>> firstLeaveGraph;
+  HighsHashTable<std::tuple<HighsInt, HighsInt, HighsUInt>> bestLeaveGraph;
+
+  HighsInt firstLeavePrefixLen;
+  HighsInt bestLeavePrefixLen;
+  HighsInt firstPathDepth;
+  HighsInt bestPathDepth;
+
+  HighsInt numAutomorphisms;
+  HighsInt numCol;
+  HighsInt numRow;
+  HighsInt numVertices;
+  HighsInt numActiveCols;
+
+  // node in the search tree for finding automorphisms
+  struct Node {
+    HighsInt stackStart;
+    HighsInt certificateEnd;
+    HighsInt targetCell;
+    HighsInt lastDistiguished;
+  };
+
+  std::vector<Node> nodeStack;
+
+  HighsInt getCellStart(HighsInt pos);
+
+  void backtrack(HighsInt backtrackStackNewEnd, HighsInt backtrackStackEnd);
+  void cleanupBacktrack(HighsInt cellCreationStackPos);
+
+  void switchToNextNode(HighsInt backtrackDepth);
+
+  bool compareCurrentGraph(
+      const HighsHashTable<std::tuple<HighsInt, HighsInt, HighsUInt>>&
+          otherGraph,
+      HighsInt& wrongCell);
+
+  void removeFixPoints();
+  void initializeGroundSet();
+  HighsHashTable<std::tuple<HighsInt, HighsInt, HighsUInt>> dumpCurrentGraph();
+  bool mergeOrbits(HighsInt v1, HighsInt v2);
+  HighsInt getOrbit(HighsInt vertex);
+
+  void initializeHashValues();
+  bool isomorphicToFirstLeave();
+  bool partitionRefinement();
+  bool checkStoredAutomorphism(HighsInt vertex);
+  u32 getVertexHash(HighsInt vertex);
+  HighsInt selectTargetCell();
+
+  bool updateCellMembership(HighsInt vertex, HighsInt cell,
+                            bool markForRefinement = true);
+  bool splitCell(HighsInt cell, HighsInt splitPoint);
+  void markCellForRefinement(HighsInt cell);
+
+  bool distinguishVertex(HighsInt targetCell);
+  bool determineNextToDistinguish();
+  void createNode();
+
+  HighsInt cellSize(HighsInt cell) const {
+    return currentPartitionLinks[cell] - cell;
+  }
+
+  bool isFromBinaryColumn(HighsInt vertex) const;
+
+  struct ComponentData {
+    HighsDisjointSets<> components;
+    std::vector<HighsInt> componentStarts;
+    std::vector<HighsInt> componentSets;
+    std::vector<HighsInt> componentNumOrbits;
+    std::vector<HighsInt> componentNumber;
+    std::vector<HighsInt> permComponentStarts;
+    std::vector<HighsInt> permComponents;
+    std::vector<HighsInt> firstUnfixed;
+    std::vector<HighsInt> numUnfixed;
+
+    HighsInt getComponentByIndex(HighsInt compIndex) const {
+      return componentNumber[compIndex];
+    }
+    HighsInt numComponents() const { return componentStarts.size() - 1; }
+    HighsInt componentSize(HighsInt component) const {
+      return componentStarts[component + 1] - componentStarts[component];
+    }
+
+    HighsInt getVertexComponent(HighsInt vertexPosition) {
+      return components.getSet(vertexPosition);
+    }
+
+    HighsInt getPermuationComponent(HighsInt permIndex) {
+      return components.getSet(firstUnfixed[permIndex]);
+    }
+  };
+
+  ComponentData computeComponentData(const HighsSymmetries& symmetries);
+
+  bool isFullOrbitope(const ComponentData& componentData, HighsInt component,
+                      HighsSymmetries& symmetries);
+
+ public:
+  void loadModelAsGraph(const HighsLp& model, double epsilon);
+
+  bool initializeDetection();
+
+  void run(HighsSymmetries& symmetries);
+};
+
+#endif

casadi/include/highs/presolve/ICrash.h

@@ -0,0 +1,127 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file presolve/ICrash.h
+ * @brief
+ * @author Julian Hall, Ivet Galabova, Qi Huangfu and Michael Feldmeier
+ */
+#ifndef PRESOLVE_QUADRATIC_CRASH_H_
+#define PRESOLVE_QUADRATIC_CRASH_H_
+
+#include <vector>
+
+#include "io/HighsIO.h"
+#include "lp_data/HStruct.h"
+#include "lp_data/HighsLp.h"
+#include "lp_data/HighsOptions.h"
+#include "lp_data/HighsStatus.h"
+
+enum class ICrashStrategy {
+  kPenalty,
+  kAdmm,
+  kICA,
+  kUpdatePenalty,
+  kUpdateAdmm
+};
+
+struct ICrashIterationDetails {
+  int num;
+  double weight;
+  double lambda_norm_2;
+
+  double lp_objective;
+  double quadratic_objective;
+  double residual_norm_2;
+
+  double time;
+};
+
+struct ICrashInfo {
+  int num_iterations;
+
+  double final_lp_objective;
+  double final_quadratic_objective;
+  double final_residual_norm_2;
+
+  double starting_weight;
+  double final_weight;
+
+  std::vector<ICrashIterationDetails> details;
+  std::vector<double> x_values;
+
+  double total_time;
+};
+
+struct ICrashOptions {
+  bool dualize;
+  ICrashStrategy strategy;
+  double starting_weight;
+  HighsInt iterations;
+  HighsInt approximate_minimization_iterations;
+  bool exact;
+  bool breakpoints;  // gets ignored if exact is set to true
+  HighsLogOptions log_options;
+};
+
+struct Quadratic {
+  const HighsLp lp;
+  const ICrashOptions options;
+  std::vector<ICrashIterationDetails> details;
+
+  HighsSolution xk;
+
+  double lp_objective;
+  double quadratic_objective;
+  std::vector<double> residual;
+  double residual_norm_2;
+
+  double mu;
+  std::vector<double> lambda;
+
+  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.
+HighsStatus callICrash(const HighsLp& lp, const ICrashOptions& options,
+                       ICrashInfo& result);
+
+// Functions: Options.
+bool checkOptions(const HighsLp& lp, const ICrashOptions options);
+Quadratic parseOptions(const HighsLp& lp, const ICrashOptions options);
+bool parseICrashStrategy(const std::string& strategy,
+                         ICrashStrategy& icrash_strategy);
+std::string ICrashtrategyToString(const ICrashStrategy strategy);
+
+// Functions: Crash.
+bool initialize(Quadratic& idata, const ICrashOptions& options);
+void update(Quadratic& idata);
+void updateParameters(Quadratic& idata, const ICrashOptions& options,
+                      const int iteration);
+bool solveSubproblem(Quadratic& idata, const ICrashOptions& options);
+
+// Functions: Util.
+double getQuadraticObjective(const Quadratic& idata);
+ICrashIterationDetails fillDetails(const int num, const Quadratic& idata);
+void fillICrashInfo(const int n_iterations, ICrashInfo& result);
+void reportSubproblem(const ICrashOptions options, const Quadratic& idata,
+                      const int iteration);
+void reportOptions(const ICrashOptions& options);
+
+bool callCrossover(const HighsLp& lp, const HighsOptions& options,
+                   const std::vector<double>& x_values, HighsSolution& solution,
+                   HighsBasis& basis, HighsCallback& callback);
+
+#endif

casadi/include/highs/presolve/ICrashUtil.h

@@ -0,0 +1,65 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file presolve/ICrashUtil.h
+ * @brief
+ * @author Julian Hall, Ivet Galabova, Qi Huangfu and Michael Feldmeier
+ */
+#ifndef PRESOLVE_ICRASH_UTIL_H_
+#define PRESOLVE_ICRASH_UTIL_H_
+
+#include <vector>
+
+#include "io/HighsIO.h"
+
+class HighsLp;
+struct HighsSolution;
+
+void convertToMinimization(HighsLp& lp);
+
+bool isEqualityProblem(const HighsLp& lp);
+
+double vectorProduct(const std::vector<double>& v1,
+                     const std::vector<double>& v2);
+
+// Calculates value of A^t*v in result.
+void muptiplyByTranspose(const HighsLp& lp, const std::vector<double>& v,
+                         std::vector<double>& result);
+
+void printMinorIterationDetails(const double iteration, const double col,
+                                const double old_value, const double update,
+                                const double ctx, const std::vector<double>& r,
+                                const double quadratic_objective,
+                                HighsLogOptions options);
+
+bool initialize(const HighsLp& lp, HighsSolution& solution,
+                std::vector<double>& lambda);
+
+double minimizeComponentQP(const int col, const double mu, const HighsLp& lp,
+                           double& objective, std::vector<double>& residual,
+                           HighsSolution& sol);
+
+double minimizeComponentIca(const int col, const double mu,
+                            const std::vector<double>& lambda,
+                            const HighsLp& lp, double& objective,
+                            std::vector<double>& residual, HighsSolution& sol);
+
+// todo:
+double minimizeComponentBreakpoints();
+
+void updateResidual(bool piecewise, const HighsLp& lp, const HighsSolution& sol,
+                    std::vector<double>& residual);
+void updateResidualFast(const HighsLp& lp, const HighsSolution& sol,
+                        std::vector<double>& residual);
+
+// Allows negative residuals
+void updateResidualIca(const HighsLp& lp, const HighsSolution& sol,
+                       std::vector<double>& residual);
+#endif

casadi/include/highs/presolve/ICrashX.h

@@ -0,0 +1,26 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+#ifndef PRESOLVE_ICRASHX_H_
+#define PRESOLVE_ICRASHX_H_
+
+#include <iostream>
+
+#include "HConfig.h"
+#include "lp_data/HighsLp.h"
+#include "lp_data/HighsSolution.h"
+
+HighsStatus callCrossover(const HighsOptions& options, const HighsLp& lp,
+                          HighsBasis& highs_basis,
+                          HighsSolution& highs_solution,
+                          HighsModelStatus& model_status, HighsInfo& highs_info,
+                          HighsCallback& highs_callback);
+
+#endif

casadi/include/highs/presolve/PresolveComponent.h

@@ -0,0 +1,93 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/*                                                                       */
+/*    This file is part of the HiGHS linear optimization suite           */
+/*                                                                       */
+/*    Written and engineered 2008-2024 by Julian Hall, Ivet Galabova,    */
+/*    Leona Gottwald and Michael Feldmeier                               */
+/*                                                                       */
+/*    Available as open-source under the MIT License                     */
+/*                                                                       */
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+/**@file PresolveComponent.h
+ * @brief The HiGHS class
+ */
+#ifndef PRESOLVE_PRESOLVE_COMPONENT_H_
+#define PRESOLVE_PRESOLVE_COMPONENT_H_
+
+// Not all necessary, but copied from Presolve.h to avoid non-Linux
+// failures
+#include <list>
+#include <map>
+#include <stack>
+#include <string>
+#include <utility>
+
+#include "lp_data/HighsLp.h"
+#include "presolve/HighsPostsolveStack.h"
+#include "util/HighsComponent.h"
+#include "util/HighsTimer.h"
+
+// Class defining the Presolve Component to be used in HiGHS.
+// What used to be in Presolve.h but allowing for further testing and dev.
+
+// The structure of component is general, of the presolve component - presolve
+// specific.
+
+struct PresolveComponentData : public HighsComponentData {
+  HighsLp reduced_lp_;
+  presolve::HighsPostsolveStack postSolveStack;
+  HighsSolution recovered_solution_;
+  HighsBasis recovered_basis_;
+  HighsPresolveLog presolve_log_;
+
+  void clear() {
+    is_valid = false;
+
+    postSolveStack = presolve::HighsPostsolveStack();
+
+    reduced_lp_.clear();
+    recovered_solution_.clear();
+    recovered_basis_.clear();
+  }
+
+  virtual ~PresolveComponentData() = default;
+};
+
+// HighsComponentInfo is a placeholder for details we want to query from outside
+// of HiGHS like execution information. Times are recorded at the end of
+// Highs::run()
+struct PresolveComponentInfo : public HighsComponentInfo {
+  HighsInt n_rows_removed = 0;
+  HighsInt n_cols_removed = 0;
+  HighsInt n_nnz_removed = 0;
+
+  double presolve_time = 0;
+  double postsolve_time = 0;
+
+  virtual ~PresolveComponentInfo() = default;
+};
+
+class PresolveComponent : public HighsComponent {
+ public:
+  void clear() override;
+
+  HighsStatus init(const HighsLp& lp, HighsTimer& timer, bool mip = false);
+
+  HighsPresolveStatus run();
+
+  HighsLp& getReducedProblem() { return data_.reduced_lp_; }
+  HighsPresolveLog& getPresolveLog() { return data_.presolve_log_; }
+
+  void negateReducedLpColDuals();
+
+  PresolveComponentInfo info_;
+  PresolveComponentData data_;
+  const HighsOptions* options_;
+  HighsTimer* timer;
+
+  HighsPresolveStatus presolve_status_ = HighsPresolveStatus::kNotPresolved;
+  HighsPostsolveStatus postsolve_status_ = HighsPostsolveStatus::kNotPresolved;
+
+  virtual ~PresolveComponent() = default;
+};
+#endif

casadi/include/highs/qpsolver/a_asm.hpp

@@ -0,0 +1,67 @@
+#ifndef __SRC_LIB_QPSOLVER_ASM_HPP__
+#define __SRC_LIB_QPSOLVER_ASM_HPP__
+
+#include "qpsolver/instance.hpp"
+#include "qpsolver/statistics.hpp"
+#include "qpsolver/qpconst.hpp"
+#include "qpsolver/settings.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

casadi/include/highs/qpsolver/a_quass.hpp

@@ -0,0 +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,
+		    HighsModelStatus& highs_model_status,
+		    HighsBasis& highs_basis,
+		    HighsSolution& highs_solution, 
+		    HighsTimer& timer);
+
+#endif