Int64 only used where necessary

Author: filikat

cmake/sources.cmake

@@ -218,7 +218,6 @@ set(factor_highs_sources
     ipm/hipo/factorhighs/Numeric.cpp
     ipm/hipo/factorhighs/SolveHandler.cpp
     ipm/hipo/factorhighs/Swaps.cpp
-    ipm/hipo/factorhighs/SymScaling.cpp
     ipm/hipo/factorhighs/Symbolic.cpp)
 
 set(factor_highs_headers
@@ -238,7 +237,6 @@ set(factor_highs_headers
     ipm/hipo/factorhighs/ReturnValues.h
     ipm/hipo/factorhighs/SolveHandler.h
     ipm/hipo/factorhighs/Swaps.h
-    ipm/hipo/factorhighs/SymScaling.h
     ipm/hipo/factorhighs/Symbolic.h
     ipm/hipo/factorhighs/Timing.h)
 

highs/ipm/hipo/auxiliary/Auxiliary.cpp

@@ -14,14 +14,14 @@ void inversePerm(const std::vector<Int>& perm, std::vector<Int>& iperm) {
   }
 }
 
-void subtreeSize(const std::vector<Int64>& parent, std::vector<Int64>& sizes) {
+void subtreeSize(const std::vector<Int>& parent, std::vector<Int>& sizes) {
   // Compute sizes of subtrees of the tree given by parent
 
-  Int64 n = parent.size();
+  Int n = parent.size();
   sizes.assign(n, 1);
 
-  for (Int64 i = 0; i < n; ++i) {
-    Int64 k = parent[i];
+  for (Int i = 0; i < n; ++i) {
+    Int k = parent[i];
     if (k != -1) sizes[k] += sizes[i];
   }
 }
@@ -82,36 +82,36 @@ void transpose(const std::vector<Int>& ptr, const std::vector<Int>& rows,
   }
 }
 
-void childrenLinkedList(const std::vector<Int64>& parent,
-                        std::vector<Int64>& head, std::vector<Int64>& next) {
+void childrenLinkedList(const std::vector<Int>& parent, std::vector<Int>& head,
+                        std::vector<Int>& next) {
   // Create linked lists of children in elimination tree.
   // parent gives the dependencies of the tree,
   // head[node] is the first child of node,
   // next[head[node]] is the second child,
   // next[next[head[node]]] is the third child...
   // until -1 is reached.
 
-  Int64 n = parent.size();
+  Int n = parent.size();
   head.assign(n, -1);
   next.assign(n, -1);
-  for (Int64 node = n - 1; node >= 0; --node) {
+  for (Int node = n - 1; node >= 0; --node) {
     if (parent[node] == -1) continue;
     next[node] = head[parent[node]];
     head[parent[node]] = node;
   }
 }
 
-void reverseLinkedList(std::vector<Int64>& head, std::vector<Int64>& next) {
+void reverseLinkedList(std::vector<Int>& head, std::vector<Int>& next) {
   // Reverse the linked list of children of each node.
   // If a node has children (a -> b -> c -> -1), the reverse list contains
   // children (c -> b -> a -> -1).
 
-  const Int64 n = head.size();
+  const Int n = head.size();
 
-  for (Int64 node = 0; node < n; ++node) {
-    Int64 prev_node = -1;
-    Int64 curr_node = head[node];
-    Int64 next_node = -1;
+  for (Int node = 0; node < n; ++node) {
+    Int prev_node = -1;
+    Int curr_node = head[node];
+    Int next_node = -1;
 
     while (curr_node != -1) {
       next_node = next[curr_node];
@@ -124,18 +124,18 @@ void reverseLinkedList(std::vector<Int64>& head, std::vector<Int64>& next) {
   }
 }
 
-void dfsPostorder(Int64 node, Int64& start, std::vector<Int64>& head,
-                  const std::vector<Int64>& next, std::vector<Int>& order) {
+void dfsPostorder(Int node, Int& start, std::vector<Int>& head,
+                  const std::vector<Int>& next, std::vector<Int>& order) {
   // Perform depth first search starting from root node and order the nodes
   // starting from the value start. head and next contain the linked list of
   // children.
 
-  std::stack<Int64> stack;
+  std::stack<Int> stack;
   stack.push(node);
 
   while (!stack.empty()) {
-    const Int64 current = stack.top();
-    const Int64 child = head[current];
+    const Int current = stack.top();
+    const Int child = head[current];
 
     if (child == -1) {
       // no children left to order,
@@ -151,9 +151,9 @@ void dfsPostorder(Int64 node, Int64& start, std::vector<Int64>& head,
   }
 }
 
-void processEdge(Int64 j, Int64 i, const std::vector<Int64>& first,
-                 std::vector<Int64>& maxfirst, std::vector<Int64>& delta,
-                 std::vector<Int64>& prevleaf, std::vector<Int64>& ancestor) {
+void processEdge(Int j, Int i, const std::vector<Int>& first,
+                 std::vector<Int>& maxfirst, std::vector<Int>& delta,
+                 std::vector<Int>& prevleaf, std::vector<Int>& ancestor) {
   // Process edge of skeleton matrix.
   // Taken from Tim Davis "Direct Methods for Sparse Linear Systems".
 
@@ -166,21 +166,21 @@ void processEdge(Int64 j, Int64 i, const std::vector<Int64>& first,
   maxfirst[i] = first[j];
 
   // previous leaf of ith row subtree
-  Int64 jprev = prevleaf[i];
+  Int jprev = prevleaf[i];
 
   // A(i,j) is in the skeleton matrix
   delta[j]++;
 
   if (jprev != -1) {
     // find least common ancestor of jprev and j
-    Int64 q = jprev;
+    Int q = jprev;
     while (q != ancestor[q]) {
       q = ancestor[q];
     }
 
     // path compression
-    Int64 sparent;
-    for (Int64 s = jprev; s != q; s = sparent) {
+    Int sparent;
+    for (Int s = jprev; s != q; s = sparent) {
       sparent = ancestor[s];
       ancestor[s] = q;
     }
@@ -193,16 +193,16 @@ void processEdge(Int64 j, Int64 i, const std::vector<Int64>& first,
   prevleaf[i] = j;
 }
 
-Int64 getDiagStart(Int64 n, Int64 k, Int64 nb, Int64 n_blocks,
+Int64 getDiagStart(Int n, Int k, Int nb, Int n_blocks,
                    std::vector<Int64>& start, bool triang) {
   // start position of diagonal blocks for blocked dense formats
   start.assign(n_blocks, 0);
-  for (Int64 i = 1; i < n_blocks; ++i) {
+  for (Int i = 1; i < n_blocks; ++i) {
     start[i] = start[i - 1] + nb * (n - (i - 1) * nb);
     if (triang) start[i] -= nb * (nb - 1) / 2;
   }
 
-  Int64 jb = std::min(nb, k - (n_blocks - 1) * nb);
+  Int jb = std::min(nb, k - (n_blocks - 1) * nb);
   Int64 result = start.back() + (n - (n_blocks - 1) * nb) * jb;
   if (triang) result -= jb * (jb - 1) / 2;
   return result;

highs/ipm/hipo/auxiliary/Auxiliary.h

@@ -12,21 +12,21 @@
 namespace hipo {
 
 void inversePerm(const std::vector<Int>& perm, std::vector<Int>& iperm);
-void subtreeSize(const std::vector<Int64>& parent, std::vector<Int64>& sizes);
+void subtreeSize(const std::vector<Int>& parent, std::vector<Int>& sizes);
 void transpose(const std::vector<Int>& ptr, const std::vector<Int>& rows,
                std::vector<Int>& ptrT, std::vector<Int>& rowsT);
 void transpose(const std::vector<Int>& ptr, const std::vector<Int>& rows,
                const std::vector<double>& val, std::vector<Int>& ptrT,
                std::vector<Int>& rowsT, std::vector<double>& valT);
-void childrenLinkedList(const std::vector<Int64>& parent,
-                        std::vector<Int64>& head, std::vector<Int64>& next);
-void reverseLinkedList(std::vector<Int64>& head, std::vector<Int64>& next);
-void dfsPostorder(Int64 node, Int64& start, std::vector<Int64>& head,
-                  const std::vector<Int64>& next, std::vector<Int>& order);
-void processEdge(Int64 j, Int64 i, const std::vector<Int64>& first,
-                 std::vector<Int64>& maxfirst, std::vector<Int64>& delta,
-                 std::vector<Int64>& prevleaf, std::vector<Int64>& ancestor);
-Int64 getDiagStart(Int64 n, Int64 k, Int64 nb, Int64 n_blocks,
+void childrenLinkedList(const std::vector<Int>& parent, std::vector<Int>& head,
+                        std::vector<Int>& next);
+void reverseLinkedList(std::vector<Int>& head, std::vector<Int>& next);
+void dfsPostorder(Int node, Int& start, std::vector<Int>& head,
+                  const std::vector<Int>& next, std::vector<Int>& order);
+void processEdge(Int j, Int i, const std::vector<Int>& first,
+                 std::vector<Int>& maxfirst, std::vector<Int>& delta,
+                 std::vector<Int>& prevleaf, std::vector<Int>& ancestor);
+Int64 getDiagStart(Int n, Int k, Int nb, Int n_blocks,
                    std::vector<Int64>& start, bool triang = false);
 
 template <typename T>
@@ -49,14 +49,14 @@ template <typename T>
 void permuteVector(std::vector<T>& v, const std::vector<Int>& perm) {
   // Permute vector v according to permutation perm.
   std::vector<T> temp_v(v);
-  for (Int64 i = 0; i < v.size(); ++i) v[i] = temp_v[perm[i]];
+  for (Int i = 0; i < v.size(); ++i) v[i] = temp_v[perm[i]];
 }
 
 template <typename T>
 void permuteVectorInverse(std::vector<T>& v, const std::vector<Int>& iperm) {
   // Permute vector v according to inverse permutation iperm.
   std::vector<T> temp_v(v);
-  for (Int64 i = 0; i < v.size(); ++i) v[iperm[i]] = temp_v[i];
+  for (Int i = 0; i < v.size(); ++i) v[iperm[i]] = temp_v[i];
 }
 
 template <typename T>

highs/ipm/hipo/auxiliary/IntConfig.h

@@ -16,8 +16,9 @@ typedef int64_t Int64;
 // kHighsIInf nonzero entries. Metis works with the same type as Int, so it must
 // be compiled accordingly.
 //
-// The factorisation uses Int64 everywhere, apart from where it interfaces with
-// the matrix stored using Int.
+// The factorisation uses a combination of Int and Int64. Int64 is used only
+// where needed, i.e. when dealing with nonzeros of the factor or when checking
+// overflows.
 // BLAS is 32-bit, so the vectors used by BLAS must be addressable with 32-bit
 // integers.
 //

highs/ipm/hipo/auxiliary/mycblas.h

@@ -6,11 +6,6 @@
 // Provide definition for cblas functions
 // Based on Netlib implementation
 
-// NB:
-// Blas is declared as using 64-bit integers.
-// The library that gets actually linked may use 32- or 64-bit integers,
-// depending on the integer model.
-
 enum CBLAS_ORDER { CblasRowMajor = 101, CblasColMajor = 102 };
 enum CBLAS_TRANSPOSE {
   CblasNoTrans = 111,
@@ -25,61 +20,63 @@ enum CBLAS_SIDE { CblasLeft = 141, CblasRight = 142 };
 extern "C" {
 #endif
 
+typedef int32_t blasint;
+
 // level 1
 
-void cblas_daxpy(const hipo::Int64 n, const double alpha, const double* x,
-                 const hipo::Int64 incx, double* y, const hipo::Int64 incy);
-void cblas_dcopy(const hipo::Int64 n, const double* x, const hipo::Int64 incx,
-                 double* y, const hipo::Int64 incy);
-void cblas_dscal(const hipo::Int64 n, const double alpha, double* x,
-                 const hipo::Int64 incx);
-void cblas_dswap(const hipo::Int64 n, double* x, const hipo::Int64 incx,
-                 double* y, const hipo::Int64 incy);
+void cblas_daxpy(const blasint n, const double alpha, const double* x,
+                 const blasint incx, double* y, const blasint incy);
+void cblas_dcopy(const blasint n, const double* x, const blasint incx,
+                 double* y, const blasint incy);
+void cblas_dscal(const blasint n, const double alpha, double* x,
+                 const blasint incx);
+void cblas_dswap(const blasint n, double* x, const blasint incx, double* y,
+                 const blasint incy);
 
 // level 2
 
 void cblas_dgemv(const enum CBLAS_ORDER order,
-                 const enum CBLAS_TRANSPOSE transa, const hipo::Int64 M,
-                 const hipo::Int64 n, const double alpha, const double* A,
-                 const hipo::Int64 lda, const double* x, const hipo::Int64 incx,
-                 const double beta, double* y, const hipo::Int64 incy);
+                 const enum CBLAS_TRANSPOSE transa, const blasint M,
+                 const blasint n, const double alpha, const double* A,
+                 const blasint lda, const double* x, const blasint incx,
+                 const double beta, double* y, const blasint incy);
 
 void cblas_dtpsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo,
                  const enum CBLAS_TRANSPOSE transa, const enum CBLAS_DIAG diag,
-                 const hipo::Int64 n, const double* ap, double* x,
-                 const hipo::Int64 incx);
+                 const blasint n, const double* ap, double* x,
+                 const blasint incx);
 
 void cblas_dtrsv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo,
                  const enum CBLAS_TRANSPOSE transa, const enum CBLAS_DIAG diag,
-                 const hipo::Int64 n, const double* a, const hipo::Int64 lda,
-                 double* x, const hipo::Int64 incx);
+                 const blasint n, const double* a, const blasint lda, double* x,
+                 const blasint incx);
 
-void cblas_dger(const enum CBLAS_ORDER order, const hipo::Int64 m,
-                const hipo::Int64 n, const double alpha, const double* x,
-                const hipo::Int64 incx, const double* y, const hipo::Int64 incy,
-                double* A, const hipo::Int64 lda);
+void cblas_dger(const enum CBLAS_ORDER order, const blasint m, const blasint n,
+                const double alpha, const double* x, const blasint incx,
+                const double* y, const blasint incy, double* A,
+                const blasint lda);
 
 // level 3
 
 void cblas_dgemm(const enum CBLAS_ORDER order,
                  const enum CBLAS_TRANSPOSE transa,
-                 const enum CBLAS_TRANSPOSE transb, const hipo::Int64 m,
-                 const hipo::Int64 n, const hipo::Int64 k, const double alpha,
-                 const double* A, const hipo::Int64 lda, const double* B,
-                 const hipo::Int64 ldb, const double beta, double* C,
-                 const hipo::Int64 ldc);
+                 const enum CBLAS_TRANSPOSE transb, const blasint m,
+                 const blasint n, const blasint k, const double alpha,
+                 const double* A, const blasint lda, const double* B,
+                 const blasint ldb, const double beta, double* C,
+                 const blasint ldc);
 
 void cblas_dsyrk(const enum CBLAS_ORDER order, const enum CBLAS_UPLO uplo,
-                 const enum CBLAS_TRANSPOSE trans, const hipo::Int64 n,
-                 const hipo::Int64 k, const double alpha, const double* a,
-                 const hipo::Int64 lda, const double beta, double* C,
-                 const hipo::Int64 ldc);
+                 const enum CBLAS_TRANSPOSE trans, const blasint n,
+                 const blasint k, const double alpha, const double* a,
+                 const blasint lda, const double beta, double* C,
+                 const blasint ldc);
 
 void cblas_dtrsm(const enum CBLAS_ORDER order, const enum CBLAS_SIDE side,
                  const enum CBLAS_UPLO uplo, const enum CBLAS_TRANSPOSE transa,
-                 const enum CBLAS_DIAG diag, const hipo::Int64 m,
-                 const hipo::Int64 n, const double alpha, const double* a,
-                 const hipo::Int64 lda, double* b, const hipo::Int64 ldb);
+                 const enum CBLAS_DIAG diag, const blasint m, const blasint n,
+                 const double alpha, const double* a, const blasint lda,
+                 double* b, const blasint ldb);
 
 #ifdef __cplusplus
 }