lpsolver 0.1.0 → 0.2.0

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/DenseFactHybrid.cpp

@@ -0,0 +1,279 @@
+#include "CallAndTimeBlas.h"
+#include "DataCollector.h"
+#include "DenseFact.h"
+#include "DgemmParallel.h"
+#include "ReturnValues.h"
+#include "Swaps.h"
+#include "ipm/hipo/auxiliary/Auxiliary.h"
+#include "ipm/hipo/auxiliary/Log.h"
+
+namespace hipo {
+
+// Factorisation with "hybrid formats".
+
+Int denseFactFH(char format, Int n, Int k, Int nb, double* A, double* B,
+                const Int* pivot_sign, double thresh, const Regul& regval,
+                double* totalreg, Int* swaps, double* pivot_2x2, bool parnode,
+                DataCollector& data) {
+  // ===========================================================================
+  // Partial blocked factorisation
+  // Matrix A is in format FH
+  // Matrix B is in format FP, if format == 'P'
+  //                       FH, if format == 'H'
+  // BLAS calls: dcopy, dscal, daxpy, dgemm, dtrsm
+  // ===========================================================================
+
+  HIPO_CLOCK_CREATE;
+
+  // check input
+  if (n < 0 || k < 0 || !A || (k < n && !B)) return kRetInvalidInput;
+
+  // quick return
+  if (n == 0) return kRetOk;
+
+  // number of blocks of columns
+  const Int n_blocks = (k - 1) / nb + 1;
+
+  // start of diagonal blocks
+  std::vector<Int64> diag_start(n_blocks);
+  getDiagStart(n, k, nb, n_blocks, diag_start);
+
+  // size of blocks
+  const Int diag_size = nb * nb;
+  const Int full_size = nb * nb;
+
+  // buffer for copy of block column
+  std::vector<double> T(n * nb);
+
+  // number of rows/columns in the Schur complement
+  const Int ns = n - k;
+
+  // number of blocks in Schur complement
+  const Int s_blocks = (ns - 1) / nb + 1;
+
+  // buffer for full-format of block of columns of Schur complement
+  std::vector<double> schur_buf;
+  if (format == 'P') schur_buf.resize(ns * nb);
+
+  // ===========================================================================
+  // LOOP OVER BLOCKS
+  // ===========================================================================
+  for (Int j = 0; j < n_blocks; ++j) {
+    // j is the index of the block column
+
+    HIPO_CLOCK_START(2);
+
+    // jb is the number of columns
+    const Int jb = std::min(nb, k - nb * j);
+
+    // size of current block could be smaller than diag_size and full_size
+    const Int this_diag_size = jb * jb;
+    const Int this_full_size = nb * jb;
+
+    // diagonal block j
+    double* D = &A[diag_start[j]];
+
+    // number of rows left below block j
+    const Int M = n - nb * j - jb;
+
+    // block of columns below diagonal block j
+    const Int64 R_pos = diag_start[j] + this_diag_size;
+    double* R = &A[R_pos];
+
+    // ===========================================================================
+    // FACTORISE DIAGONAL BLOCK
+    // ===========================================================================
+    double max_in_R = -1.0;
+    if (jb == 1) {
+      for (Int64 i = 0; i < M * jb; ++i)
+        max_in_R = std::max(max_in_R, std::abs(R[i]));
+    }
+
+    double* regul_current = &totalreg[j * nb];
+    std::vector<Int> pivot_sign_current(&pivot_sign[j * nb],
+                                        &pivot_sign[j * nb] + jb);
+    Int* swaps_current = &swaps[j * nb];
+    double* pivot_2x2_current = &pivot_2x2[j * nb];
+    Int info =
+        denseFactK('U', jb, D, jb, pivot_sign_current.data(), thresh, regval,
+                   regul_current, swaps_current, pivot_2x2_current, data);
+    if (info != 0) return info;
+
+#ifdef HIPO_PIVOTING
+    // swap columns in R
+    applySwaps(swaps_current, M, jb, R, data);
+
+    // unswap regularisation, to keep it with original ordering
+    permuteWithSwaps(regul_current, swaps_current, jb, true);
+#endif
+
+    if (M > 0) {
+      // ===========================================================================
+      // SOLVE COLUMNS
+      // ===========================================================================
+      // solve block R with D
+      callAndTime_dtrsm('L', 'U', 'T', 'U', jb, M, 1.0, D, jb, R, jb, data);
+
+      // make copy of partially solved columns
+      callAndTime_dcopy(jb * M, R, 1, T.data(), 1, data);
+
+      // solve block R with pivots
+      Int step = 1;
+      for (Int col = 0; col < jb; col += step) {
+        if (pivot_2x2_current[col] == 0.0) {
+          // 1x1 pivots
+          step = 1;
+          callAndTime_dscal(M, D[col + jb * col], &R[col], jb, data);
+        } else {
+          // 2x2 pivots
+          step = 2;
+
+          // columns affected
+          double* c1 = &R[col];
+          double* c2 = &R[col + 1];
+
+          // inverse of 2x2 pivot
+          double i_d1 = D[col + jb * col];
+          double i_d2 = D[col + 1 + jb * (col + 1)];
+          double i_off = pivot_2x2_current[col];
+
+          // copy of original col1
+          std::vector<double> c1_temp(M);
+          callAndTime_dcopy(M, c1, jb, c1_temp.data(), 1, data);
+
+          // solve col and col+1
+          callAndTime_dscal(M, i_d1, c1, jb, data);
+          callAndTime_daxpy(M, i_off, c2, jb, c1, jb, data);
+          callAndTime_dscal(M, i_d2, c2, jb, data);
+          callAndTime_daxpy(M, i_off, c1_temp.data(), 1, c2, jb, data);
+        }
+      }
+
+      // check entries of L
+      /*double max_in_R = -1.0;
+      for (Int64 i = 0; i < M * jb; ++i) {
+        max_in_R = std::max(max_in_R, std::abs(R[i]));
+      }
+      if (max_in_R > 1e8) printf("%.1e, %5d %5d\n", max_in_R, jb, M);*/
+
+      // ===========================================================================
+      // UPDATE FRONTAL
+      // ===========================================================================
+      Int64 offset{};
+
+      // go through remaining blocks of columns
+      for (Int jj = j + 1; jj < n_blocks; ++jj) {
+        // number of columns in block jj
+        const Int col_jj = std::min(nb, k - nb * jj);
+
+        // number of rows in block jj
+        const Int row_jj = n - nb * jj;
+
+        const double* P = &T[offset];
+        double* Q = &A[diag_start[jj]];
+        const double* Rjj = &R[offset];
+
+        // perform gemm (potentially) in parallel
+        if (parnode)
+          dgemmParallel(P, Rjj, Q, col_jj, jb, row_jj, nb, 1.0, data);
+        else
+          callAndTime_dgemm('T', 'N', col_jj, row_jj, jb, -1.0, P, jb, Rjj, jb,
+                            1.0, Q, col_jj, data);
+
+        offset += jb * col_jj;
+      }
+      HIPO_CLOCK_STOP(2, data, kTimeDenseFact_main);
+      
+      // ===========================================================================
+      // UPDATE SCHUR COMPLEMENT
+      // ===========================================================================
+      HIPO_CLOCK_START(2);
+      if (k < n) {
+        Int64 B_offset{};
+
+        // go through blocks of columns of the Schur complement
+        for (Int sb = 0; sb < s_blocks; ++sb) {
+          // number of rows of the block
+          const Int nrow = ns - nb * sb;
+
+          // number of columns of the block
+          const Int ncol = std::min(nb, nrow);
+
+          const double* P = &T[offset];
+          double* Q = format == 'P' ? schur_buf.data() : &B[B_offset];
+          const double* Rjj = &R[offset];
+
+          // beta is 0 to avoid initialising schur_buf if format=='P'
+          double beta = format == 'P' ? 0.0 : 1.0;
+
+          // perform gemm (potentially) in parallel
+          if (parnode)
+            dgemmParallel(P, Rjj, Q, ncol, jb, nrow, nb, beta, data);
+          else
+            callAndTime_dgemm('T', 'N', ncol, nrow, jb, -1.0, P, jb, Rjj, jb,
+                              beta, Q, ncol, data);
+
+          if (format == 'P') {
+            // schur_buf contains Schur complement in hybrid format (with full
+            // diagonal blocks). Store it by columns in B (with full diagonal
+            // blocks).
+            for (Int buf_row = 0; buf_row < nrow; ++buf_row) {
+              const Int N = ncol;
+              callAndTime_daxpy(N, 1.0, &schur_buf[buf_row * ncol], 1,
+                                &B[B_offset + buf_row], nrow, data);
+            }
+          }
+
+          B_offset += nrow * ncol;
+          offset += jb * ncol;
+        }
+      }
+      HIPO_CLOCK_STOP(2, data, kTimeDenseFact_schur);
+    }
+  }
+
+  return kRetOk;
+}
+
+Int denseFactFP2FH(double* A, Int nrow, Int ncol, Int nb, DataCollector& data) {
+  // ===========================================================================
+  // Packed to Hybrid conversion
+  // Matrix A on  input is in format FP
+  // Matrix A on output is in format FH
+  // BLAS calls: dcopy
+  // ===========================================================================
+
+  HIPO_CLOCK_CREATE;
+
+  std::vector<double> buf(nrow * nb);
+
+  Int64 startAtoBuf = 0;
+  Int64 startBuftoA = 0;
+
+  for (Int k = 0; k <= (ncol - 1) / nb; ++k) {
+    // Number of columns in the block. Can be smaller than nb for last block.
+    const Int block_size = std::min(nb, ncol - k * nb);
+
+    // Number of rows in the block
+    const Int row_size = nrow - k * nb;
+
+    // Copy block into buf
+    callAndTime_dcopy(row_size * block_size, &A[startAtoBuf], 1, buf.data(), 1,
+                      data);
+    startAtoBuf += row_size * block_size;
+
+    // Copy columns back into A, row by row.
+    // One call of dcopy_ for each row of the block of columns.
+    for (Int i = 0; i < row_size; ++i) {
+      const Int N = block_size;
+      callAndTime_dcopy(N, &buf[i], row_size, &A[startBuftoA], 1, data);
+      startBuftoA += N;
+    }
+  }
+
+  HIPO_CLOCK_STOP(2, data, kTimeDenseFact_convert);
+
+  return kRetOk;
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/DenseFactKernel.cpp

@@ -0,0 +1,284 @@
+#include "CallAndTimeBlas.h"
+#include "DataCollector.h"
+#include "DenseFact.h"
+#include "FactorHiGHSSettings.h"
+#include "ReturnValues.h"
+#include "Swaps.h"
+#include "ipm/hipo/auxiliary/Auxiliary.h"
+#include "ipm/hipo/auxiliary/Log.h"
+#include "util/HighsRandom.h"
+
+namespace hipo {
+
+// Dense Factorisation kernel
+
+static std::pair<Int, double> maxInCol(Int j, Int n, Int m, double* A,
+                                       Int lda) {
+  // Given the symemtric matrix A, of size nxn, accessed with leading dimension
+  // lda, in upper triangular format, ignoring rows 0:j-1, find the maximum in
+  // row/col m.
+
+  double maxval = -1.0;
+  Int r = -1;
+  // scan column m, rows j:m-1
+  for (Int row = j; row < m; ++row) {
+    double val = std::abs(A[row + lda * m]);
+    if (val > maxval) {
+      maxval = val;
+      r = row;
+    }
+  }
+  // scan row m, columns m+1:n
+  for (Int col = m + 1; col < n; ++col) {
+    double val = std::abs(A[m + lda * col]);
+    if (val > maxval) {
+      maxval = val;
+      r = col;
+    }
+  }
+  return {r, maxval};
+}
+
+static void staticReg(double& pivot, Int sign, const Regul& regval,
+                      double& totalreg) {
+  // apply static regularisation
+
+  double old_pivot = pivot;
+  if (sign > 0)
+    pivot += regval.primal;
+  else
+    pivot -= regval.dual;
+  totalreg = pivot - old_pivot;
+}
+
+static bool blockBunchKaufman(Int j, Int n, double* A, Int lda, Int* swaps,
+                              Int* sign, double thresh, const Regul& regval,
+                              double* totalreg, DataCollector& data) {
+  // Perform Bunch-Kaufman pivoting within a block of the supernode (see Schenk,
+  // Gartner, ETNA 2006).
+  // It works only for upper triangular A.
+  // Return true if 2x2 pivot should be used, false otherwise.
+  // Swap of columns may be performed.
+  // Regularisation of pivot may be performed.
+
+  HIPO_CLOCK_CREATE;
+
+  bool flag_2x2 = false;
+
+  // Find largest diagonal entry in the residual part of the block
+  Int ind_max_diag = -1;
+  double max_diag = -1.0;
+  for (Int i = j; i < n; ++i) {
+    double val = std::abs(A[i + lda * i]);
+    if (val > max_diag) {
+      max_diag = val;
+      ind_max_diag = i;
+    }
+  }
+  assert(ind_max_diag >= j);
+
+  // put column with max pivot as first column
+  swapCols('U', n, A, lda, j, ind_max_diag, swaps, sign, data);
+
+  // Max in column j of diagonal block
+  auto res = maxInCol(j, n, j, A, lda);
+  double gamma_j = res.second;
+  Int r = res.first;
+  double Ajj = sign[j] > 0 ? A[j + lda * j] + regval.dual
+                           : A[j + lda * j] - regval.primal;
+
+  if (std::max(std::abs(Ajj), gamma_j) <= thresh || sign[j] * Ajj < 0 ||
+      j == n - 1) {
+    // Must accept current pivot
+    double old_pivot = A[j + lda * j];
+    staticReg(A[j + lda * j], sign[j], regval, totalreg[j]);
+
+    if (sign[j] * A[j + lda * j] < 0) {
+      data.setWrongSign(A[j + lda * j]);
+      // A[j + lda * j] = sign[j] * thresh;
+    }
+
+    if (std::max(std::abs(Ajj), gamma_j) < thresh) {
+      // perturbe pivot
+      A[j + lda * j] = sign[j] * thresh;
+      data.countRegPiv();
+    }
+    totalreg[j] = A[j + lda * j] - old_pivot;
+    data.setMaxReg(std::abs(totalreg[j]));
+
+  } else {
+    // Max in column r of diagonal block
+    assert(r >= 0);
+    res = maxInCol(j, n, r, A, lda);
+    double gamma_r = res.second;
+    double Arr = sign[r] > 0 ? A[r + lda * r] + regval.primal
+                             : A[r + lda * r] - regval.dual;
+
+    if ((std::abs(Ajj) >= kAlphaBK * gamma_j ||
+         std::abs(Ajj) * gamma_r >= kAlphaBK * gamma_j * gamma_j)) {
+      // Accept current pivot
+      staticReg(A[j + lda * j], sign[j], regval, totalreg[j]);
+
+      if (sign[j] * A[j + lda * j] < 0) data.setWrongSign(A[j + lda * j]);
+
+    } else if (std::abs(Arr) >= kAlphaBK * gamma_r) {
+      // Use pivot r
+
+      swapCols('U', n, A, lda, j, r, swaps, sign, data);
+      staticReg(A[j + lda * j], sign[j], regval, totalreg[j]);
+
+      if (sign[j] * A[j + lda * j] < 0) data.setWrongSign(A[j + lda * j]);
+
+    } else {
+      // Use 2x2 pivot (j,r)
+
+      swapCols('U', n, A, lda, j + 1, r, swaps, sign, data);
+      flag_2x2 = true;
+      staticReg(A[j + lda * j], sign[j], regval, totalreg[j]);
+      staticReg(A[j + 1 + lda * (j + 1)], sign[j + 1], regval, totalreg[j + 1]);
+
+      if (sign[j] * A[j + lda * j] < 0) data.setWrongSign(A[j + lda * j]);
+      if (sign[j + 1] * A[j + 1 + lda * (j + 1)] < 0)
+        data.setWrongSign(A[j + 1 + lda * (j + 1)]);
+    }
+  }
+
+  HIPO_CLOCK_STOP(2, data, kTimeDenseFact_pivoting);
+  return flag_2x2;
+}
+
+Int denseFactK(char uplo, Int n, double* A, Int lda, Int* pivot_sign,
+               double thresh, const Regul& regval, double* totalreg, Int* swaps,
+               double* pivot_2x2, DataCollector& data) {
+  // ===========================================================================
+  // Factorisation kernel
+  // Matrix A is in format F
+  // BLAS calls: dscal, dcopy, dger
+  // ===========================================================================
+
+  // check input
+  if (n < 0 || !A || lda < n) return kRetInvalidInput;
+
+  // quick return
+  if (n == 0) return kRetOk;
+
+  HIPO_CLOCK_CREATE;
+
+  if (uplo == 'L') {
+    assert(1 == 0);
+  } else {
+    if (!swaps || !pivot_2x2) return kRetInvalidInput;
+
+    // initialise order of pivots
+    for (Int i = 0; i < n; ++i) swaps[i] = i;
+
+    // allocate space for copy of col(s)
+    std::vector<double> temp(n - 1);
+    std::vector<double> temp2(n - 1);
+
+    Int step = 1;
+
+    for (Int j = 0; j < n; j += step) {
+      bool flag_2x2 = false;
+
+#ifdef HIPO_PIVOTING
+      flag_2x2 = blockBunchKaufman(j, n, A, lda, swaps, pivot_sign, thresh,
+                                   regval, totalreg, data);
+#endif
+
+      // cannot do 2x2 pivoting on last column
+      assert(j < n - 1 || flag_2x2 == false);
+
+      if (!flag_2x2) {
+        // 1x1 pivots
+        step = 1;
+
+        // diagonal element
+        double Ajj = A[j + lda * j];
+
+        if (std::isnan(Ajj)) return kRetInvalidPivot;
+
+        // add regularisation
+        staticReg(Ajj, pivot_sign[j], regval, totalreg[j]);
+
+#ifndef HIPO_PIVOTING
+        // add static regularisation
+        staticReg(Ajj, pivot_sign[j], regul[j]);
+        data.setMaxReg(std::abs(regul[j]));
+#endif
+
+        // save reciprocal of pivot
+        A[j + lda * j] = 1.0 / Ajj;
+
+        const Int M = n - j - 1;
+        if (M > 0) {
+          // make copy of row
+          callAndTime_dcopy(M, &A[j + (j + 1) * lda], lda, temp.data(), 1,
+                            data);
+
+          // scale row j
+          callAndTime_dscal(M, 1.0 / Ajj, &A[j + (j + 1) * lda], lda, data);
+
+          // update rest of the matrix
+          callAndTime_dger(M, M, -1.0, temp.data(), 1, &A[j + (j + 1) * lda],
+                           lda, &A[j + 1 + (j + 1) * lda], lda, data);
+        }
+      } else {
+        // 2x2 pivots
+        step = 2;
+
+        // diagonal pivot elements
+        const double d1 = A[j + lda * j];
+        const double d2 = A[j + 1 + lda * (j + 1)];
+
+        if (std::isnan(d1) || std::isnan(d2)) return kRetInvalidPivot;
+
+        // off-diagonal pivot element
+        const double offd = A[j + lda * (j + 1)];
+        A[j + lda * (j + 1)] = 0.0;
+
+        // compute coefficients of 2x2 inverse
+        const double denom = d1 * d2 - offd * offd;
+        const double i_d1 = d2 / denom;
+        const double i_d2 = d1 / denom;
+        const double i_off = -offd / denom;
+
+        // save them in place of pivots
+        A[j + lda * j] = i_d1;
+        A[j + 1 + lda * (j + 1)] = i_d2;
+        pivot_2x2[j] = i_off;
+
+        const Int M = n - j - 2;
+        if (M > 0) {
+          double* r1 = &A[j + (j + 2) * lda];
+          double* r2 = &A[j + 1 + (j + 2) * lda];
+
+          // make a copy of first row
+          callAndTime_dcopy(M, r1, lda, temp.data(), 1, data);
+
+          // make a copy of second row
+          callAndTime_dcopy(M, r2, lda, temp2.data(), 1, data);
+
+          // solve rows j,j+1
+          callAndTime_dscal(M, i_d1, r1, lda, data);
+          callAndTime_daxpy(M, i_off, temp2.data(), 1, r1, lda, data);
+          callAndTime_dscal(M, i_d2, r2, lda, data);
+          callAndTime_daxpy(M, i_off, temp.data(), 1, r2, lda, data);
+
+          // update rest of the matrix
+          callAndTime_dger(M, M, -1.0, temp.data(), 1, r1, lda,
+                           &A[j + 2 + (j + 2) * lda], lda, data);
+          callAndTime_dger(M, M, -1.0, temp2.data(), 1, r2, lda,
+                           &A[j + 2 + (j + 2) * lda], lda, data);
+        }
+
+        data.count2x2();
+      }
+    }
+  }
+
+  HIPO_CLOCK_STOP(2, data, kTimeDenseFact_kernel);
+  return kRetOk;
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/DgemmParallel.cpp

@@ -0,0 +1,38 @@
+#include "DgemmParallel.h"
+
+#include "CallAndTimeBlas.h"
+#include "FactorHiGHSSettings.h"
+#include "parallel/HighsParallel.h"
+
+namespace hipo {
+
+dgemmParalleliser::dgemmParalleliser(const double* P, const double* R,
+                                     double* Q, Int col, Int jb,
+                                     DataCollector& data)
+    : P_{P}, R_{R}, Q_{Q}, col_{col}, jb_{jb}, data_{data} {}
+
+void dgemmParalleliser::run(Int start, Int end, double beta) const {
+  callAndTime_dgemm('T', 'N', col_, end - start, jb_, -1.0, P_, jb_,
+                    &R_[start * jb_], jb_, beta, &Q_[start * col_], col_,
+                    data_);
+}
+
+void dgemmParallel(const double* P, const double* R, double* Q, Int col, Int jb,
+                   Int row, Int nb, double beta, DataCollector& data) {
+  // if there is enough work to be done, parallelise
+  if (col >= nb / 2 && jb >= nb / 2 && row >= kBlockParallelThreshold * nb) {
+    dgemmParalleliser gemmP(P, R, Q, col, jb, data);
+    dgemmParalleliser* pt = &gemmP;
+
+    // I need to use an object to call gemm, otherwise the task is too large and
+    // static_assert in the parallel deque fails.
+    highs::parallel::for_each(
+        0, row, [pt, beta](Int start, Int end) { pt->run(start, end, beta); },
+        kBlockGrainSize * jb);
+  } else {
+    callAndTime_dgemm('T', 'N', col, row, jb, -1.0, P, jb, R, jb, beta, Q, col,
+                      data);
+  }
+}
+
+}  // namespace hipo

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/DgemmParallel.h

@@ -0,0 +1,32 @@
+#ifndef FACTORHIGHS_DGEMM_PARALLEL_H
+#define FACTORHIGHS_DGEMM_PARALLEL_H
+
+#include "DataCollector.h"
+#include "ipm/hipo/auxiliary/IntConfig.h"
+
+namespace hipo {
+
+// parallelise dgemm for use within factorisation
+// Performs Q <- Q - R P^T in hybrid format.
+// Parallelised over the rows of R and Q.
+class dgemmParalleliser {
+  const double* P_;
+  const double* R_;
+  double* Q_;
+  const Int col_;
+  const Int jb_;
+  DataCollector& data_;
+
+ public:
+  dgemmParalleliser(const double* P, const double* R, double* Q, Int col,
+                    Int jb, DataCollector& data);
+
+  void run(Int start, Int end, double beta) const;
+};
+
+void dgemmParallel(const double* P, const double* R, double* Q, Int col, Int jb,
+                   Int row, Int nb, double beta, DataCollector& data);
+
+}  // namespace hipo
+
+#endif

data/ext/lpsolver-highs/highs/ipm/hipo/factorhighs/FactorHiGHS.cpp

@@ -0,0 +1,57 @@
+#include "FactorHiGHS.h"
+
+#include "Analyse.h"
+#include "DataCollector.h"
+#include "Factorise.h"
+#include "ipm/hipo/auxiliary/Log.h"
+
+namespace hipo {
+
+FHsolver::FHsolver(const Log* log, Int block_size)
+    : log_{log}, nb_{block_size > 0 ? block_size : default_nb_} {
+#ifdef HIPO_COLLECT_EXPENSIVE_DATA
+  if (log_)
+    log_->printw(
+        "Running in debug mode: COLLECTING EXPENSIVE FACTORISATION DATA\n");
+#endif
+#if HIPO_TIMING_LEVEL > 0
+  if (log_)
+    log_->printw("Running in debug mode: COLLECTING EXPENSIVE TIMING DATA\n");
+#endif
+}
+
+FHsolver::~FHsolver() {
+  if (log_) {
+    data_.printTimes(*log_);
+    data_.printIter(*log_);
+  }
+}
+
+void FHsolver::newIter() { data_.append(); }
+
+void FHsolver::setRegularisation(double reg_p, double reg_d) {
+  regul_.primal = reg_p;
+  regul_.dual = reg_d;
+}
+
+Int FHsolver::analyse(Symbolic& S, const std::vector<Int>& rows,
+                      const std::vector<Int>& ptr,
+                      const std::vector<Int>& signs,
+                      const std::vector<Int>& perm) {
+  Analyse an_obj(rows, ptr, signs, nb_, log_, data_, perm);
+  return an_obj.run(S);
+}
+
+Int FHsolver::factorise(const Symbolic& S, const std::vector<Int>& rows,
+                        const std::vector<Int>& ptr,
+                        const std::vector<double>& vals) {
+  Factorise fact_obj(S, rows, ptr, vals, regul_, log_, data_, sn_columns_,
+                     &serial_stack_);
+  return fact_obj.run(N_);
+}
+
+Int FHsolver::solve(std::vector<double>& x) { return N_.solve(x); }
+
+void FHsolver::getRegularisation(std::vector<double>& reg) { N_.getReg(reg); }
+
+}  // namespace hipo