Interface to Numeric back to normal, still ugly

Author: filikat

highs/ipm/hipo/factorhighs/FactorHiGHS.cpp

@@ -45,15 +45,8 @@ Int FHsolver::factorise(Numeric& N, const Symbolic& S,
                         const std::vector<Int>& rows,
                         const std::vector<Int>& ptr,
                         const std::vector<double>& vals) {
-  if (sn_columns_.empty()) {
-    sn_columns_.resize(S.sn());
-    printf("Resizing\n");
-  }
-
   Factorise fact_obj(S, rows, ptr, vals, regul_, log_, data_, sn_columns_);
   return fact_obj.run(N);
 }
 
-std::vector<std::vector<double>>& FHsolver::columns() { return sn_columns_; }
-
 }  // namespace hipo

highs/ipm/hipo/factorhighs/FactorHiGHS.h

@@ -99,8 +99,6 @@ class FHsolver {
   // Set values for static regularisation to be added when a pivot is selected.
   // If regularisation is already added to the matrix, ignore.
   void setRegularisation(double reg_p, double reg_d);
-
-  std::vector<std::vector<double>>& columns();
 };
 
 /* To do
@@ -123,6 +121,12 @@ class FHsolver {
   probably considerably increase the memory usage though and the stack approach
   is to be preferred. However, the latter requires a different parallelisation.
 
+
+- at the moment, I managed to keep the same interface to Numeric, but it's a bit
+  ugly. Maybe Numeric should be an object that is crested by Factorise, which
+  only contains pointers to data. Then I can just copy into the general numeric
+  object within FactorHiGHSSolver and include the pointers to the most up to
+  date data.
 */
 
 }  // namespace hipo

highs/ipm/hipo/factorhighs/Factorise.cpp

@@ -360,7 +360,7 @@ bool Factorise::run(Numeric& num) {
 
   // allocate space for list of generated elements and columns of L
   schur_contribution_.resize(S_.sn());
-  // sn_columns_.resize(S_.sn());
+  sn_columns_.resize(S_.sn());
   swaps_.resize(S_.sn());
   pivot_2x2_.resize(S_.sn());
 
@@ -388,6 +388,7 @@ bool Factorise::run(Numeric& num) {
   if (flag_stop_) return true;
 
   // move factorisation to numerical object
+  num.sn_columns_ = &sn_columns_;
   num.total_reg_ = std::move(total_reg_);
   num.swaps_ = std::move(swaps_);
   num.pivot_2x2_ = std::move(pivot_2x2_);

highs/ipm/hipo/factorhighs/Numeric.cpp

@@ -12,16 +12,16 @@
 
 namespace hipo {
 
-Numeric::Numeric(const Symbolic& S,
-                 std::vector<std::vector<double>>& sn_columns)
-    : S_{S}, sn_columns_{sn_columns} {
-  // initialise solve handler
-  SH_.reset(new HybridSolveHandler(S_, sn_columns_, swaps_, pivot_2x2_));
-}
+Numeric::Numeric(const Symbolic& S) : S_{S} {}
 
 std::pair<Int, double> Numeric::solve(std::vector<double>& x) const {
   // Return the number of solves performed
 
+  assert(sn_columns_);
+
+  // initialise solve handler
+  SH_.reset(new HybridSolveHandler(S_, *sn_columns_, swaps_, pivot_2x2_));
+
   SH_->setData(data_);
 
 #if HIPO_TIMING_LEVEL >= 1

highs/ipm/hipo/factorhighs/Numeric.h

@@ -13,7 +13,7 @@ namespace hipo {
 
 class Numeric {
   // columns of factorisation, stored by supernode
-  const std::vector<std::vector<double>>& sn_columns_;
+  const std::vector<std::vector<double>>* sn_columns_ = nullptr;
 
   // swaps of columns for each supernode, ordered locally within a block
   std::vector<std::vector<Int>> swaps_{};
@@ -25,7 +25,7 @@ class Numeric {
   const Symbolic& S_;
 
   // object to handle solve phase in different formats
-  std::unique_ptr<SolveHandler> SH_;
+  mutable std::unique_ptr<SolveHandler> SH_;
 
   // lower triangle of original matrix, permuted
   std::vector<Int> rowsA_{};
@@ -43,7 +43,7 @@ class Numeric {
   // dynamic regularisation applied to the matrix
   std::vector<double> total_reg_{};
 
-  Numeric(const Symbolic& S, std::vector<std::vector<double>>& sn_columns);
+  Numeric(const Symbolic& S);
 
   // Full solve with refinement
   // Return pair (number of solves, final residual)

highs/ipm/hipo/ipm/FactorHiGHSSolver.cpp

@@ -13,7 +13,7 @@ FactorHiGHSSolver::FactorHiGHSSolver(Options& options, const Model& model,
                                      IpmData* record, const LogHighs& log)
     : FH_(&log, options.block_size),
       S_{},
-      N_(S_, FH_.columns()),
+      N_(S_),
       regul_{regul},
       info_{info},
       data_{record},