make local functions static

- avoid missing-declaration warnings, and allows inlining

Author: svigerske

highs/ipm/hipo/auxiliary/KrylovMethods.cpp

@@ -8,12 +8,12 @@
 
 namespace hipo {
 
-void applyRotation(double& x, double& y, double c, double s) {
+static void applyRotation(double& x, double& y, double c, double s) {
   double t = c * x + s * y;
   y = -s * x + c * y;
   x = t;
 }
-void getRotation(double x, double y, double& c, double& s) {
+static void getRotation(double x, double y, double& c, double& s) {
   if (y == 0.0) {
     c = 1.0;
     s = 0.0;
@@ -27,8 +27,8 @@ void getRotation(double x, double y, double& c, double& s) {
     s = t * c;
   }
 }
-void update(std::vector<double>& x, Int k, std::vector<double>& H, Int ldh,
-            std::vector<double>& s, std::vector<std::vector<double>>& V) {
+static void update(std::vector<double>& x, Int k, std::vector<double>& H, Int ldh,
+                   std::vector<double>& s, std::vector<std::vector<double>>& V) {
   // Solve H * y = s
   std::vector<double> y = s;
   for (Int i = k; i >= 0; --i) {

highs/ipm/hipo/factorhighs/DenseFactKernel.cpp

@@ -11,7 +11,7 @@ namespace hipo {
 
 // Dense Factorisation kernel
 
-std::pair<Int, double> maxInCol(Int j, Int n, Int m, double* A, Int lda) {
+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.
@@ -37,7 +37,7 @@ std::pair<Int, double> maxInCol(Int j, Int n, Int m, double* A, Int lda) {
   return {r, maxval};
 }
 
-void staticReg(double& pivot, Int sign, const Regul& regval, double& totalreg) {
+static void staticReg(double& pivot, Int sign, const Regul& regval, double& totalreg) {
   // apply static regularisation
 
   double old_pivot = pivot;
@@ -48,9 +48,9 @@ void staticReg(double& pivot, Int sign, const Regul& regval, double& totalreg) {
   totalreg = pivot - old_pivot;
 }
 
-bool blockBunchKaufman(Int j, Int n, double* A, Int lda, Int* swaps, Int* sign,
-                       double thresh, const Regul& regval, double* totalreg,
-                       DataCollector& data) {
+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.

highs/ipm/hipo/factorhighs/SymScaling.cpp

@@ -7,9 +7,9 @@
 
 namespace hipo {
 
-void product(const std::vector<double>& x, std::vector<double>& y,
-             const std::vector<Int>& ptr, const std::vector<Int>& rows,
-             const std::vector<double>& N) {
+static void product(const std::vector<double>& x, std::vector<double>& y,
+                    const std::vector<Int>& ptr, const std::vector<Int>& rows,
+                    const std::vector<double>& N) {
   // Multiply by matrix E, i.e. matrix A with all entries equal to one, in lower
   // triangular form, and sum component-wise product of N with x.
   // E * x + N .* x= y
@@ -30,10 +30,10 @@ void product(const std::vector<double>& x, std::vector<double>& y,
   // multiply by N
   for (Int i = 0; i < n; ++i) y[i] += N[i] * x[i];
 }
-void CG_for_CR_scaling(const std::vector<double>& b, std::vector<double>& x,
-                       const std::vector<double>& N,
-                       const std::vector<Int>& ptr,
-                       const std::vector<Int>& rows) {
+static void CG_for_CR_scaling(const std::vector<double>& b, std::vector<double>& x,
+                              const std::vector<double>& N,
+                              const std::vector<Int>& ptr,
+                              const std::vector<Int>& rows) {
   Int n = N.size();
 
   // initial residual

highs/ipm/hipo/factorhighs/Symbolic.cpp

@@ -45,7 +45,7 @@ const std::vector<Int>& Symbolic::snParent() const { return sn_parent_; }
 const std::vector<Int>& Symbolic::snStart() const { return sn_start_; }
 const std::vector<Int>& Symbolic::pivotSign() const { return pivot_sign_; }
 
-std::string memoryString(double mem) {
+static std::string memoryString(double mem) {
   std::stringstream ss;
 
   if (mem < 1024)

highs/ipm/hipo/ipm/CurtisReidScaling.cpp

@@ -7,8 +7,8 @@
 
 namespace hipo {
 
-void product(const double* x, std::vector<double>& y,
-             const std::vector<Int>& ptr, const std::vector<Int>& rows) {
+static void product(const double* x, std::vector<double>& y,
+                    const std::vector<Int>& ptr, const std::vector<Int>& rows) {
   // Multiply by matrix E, i.e. matrix A with all entries equal to one
   // E * x = y
   Int n = ptr.size() - 1;
@@ -19,9 +19,9 @@ void product(const double* x, std::vector<double>& y,
   }
 }
 
-void product_transpose(const double* x, std::vector<double>& y,
-                       const std::vector<Int>& ptr,
-                       const std::vector<Int>& rows) {
+static void product_transpose(const double* x, std::vector<double>& y,
+                              const std::vector<Int>& ptr,
+                              const std::vector<Int>& rows) {
   // Multiply by matrix E^T, i.e. matrix A^T with all entries equal to one
   // E^T * x = y
   Int n = ptr.size() - 1;

highs/ipm/hipo/ipm/FactorHiGHSSolver.cpp

@@ -25,8 +25,8 @@ void FactorHiGHSSolver::clear() {
   FH_.newIter();
 }
 
-Int getASstructure(const HighsSparseMatrix& A, std::vector<Int>& ptr,
-                   std::vector<Int>& rows) {
+static Int getASstructure(const HighsSparseMatrix& A, std::vector<Int>& ptr,
+                          std::vector<Int>& rows) {
   // Augmented system structure
 
   Int nA = A.num_col_;