Extra warnings added and fixes to make them clear

.github/workflows/ci.yml

@@ -17,7 +17,7 @@ jobs:
             debug:        0
             noalligather: 0
             mpich:        0
-            threadoff:    0
+            numthread:    1
             elsi:         0
           - name:         ubuntu-debug
             os:           ubuntu-latest
@@ -27,7 +27,7 @@ jobs:
             debug:        1
             noalligather: 0
             mpich:        0
-            threadoff:    0
+            numthread:    1
             elsi:         0
           - name:         ubuntu-nogather
             os:           ubuntu-latest
@@ -37,7 +37,7 @@ jobs:
             debug:        0
             noalligather: 1
             mpich:        0
-            threadoff:    0
+            numthread:    1
             elsi:         0
           - name:         ubuntu-mpich
             os:           ubuntu-latest
@@ -47,7 +47,7 @@ jobs:
             debug:        0
             noalligather: 0
             mpich:        1
-            threadoff:    0
+            numthread:    3
             elsi:         0
           - name:         mac-thread-cap
             os:           macos-latest
@@ -57,7 +57,7 @@ jobs:
             debug:        0
             noalligather: 0
             mpich:        0
-            threadoff:    1
+            numthread:    3
             elsi:         0
           - name:         mac
             os:           macos-latest
@@ -68,7 +68,7 @@ jobs:
             noalligather: 0
             mpich:        0
             lint:         1
-            threadoff:    0
+            numthread:    3
             elsi:         1
     runs-on:              ${{ matrix.os }}
     steps:
@@ -92,7 +92,7 @@ jobs:
       env:
         MAKETEST:         ${{ matrix.maketest }}
         TESTOS:           ${{ matrix.testos }}
-        THREADOFF:        ${{ matrix.threadoff }}
+        OMP_NUM_THREADS:  ${{ matrix.numthread }}
     - name:               check examples
       run:                |
         bash -l UnitTests/check_examples.sh

CMakeLists.txt

@@ -1,7 +1,7 @@
 ################################################################################
 ## Basic Setup
 cmake_minimum_required (VERSION 3.9)
-project(NTPoly VERSION 2.7.0 DESCRIPTION 
+project(NTPoly VERSION 3.1.0 DESCRIPTION 
 	"A parallel library for computing the functions of sparse matrices")
 enable_language(Fortran)
 

Source/C/TripletList_c.h

@@ -8,7 +8,7 @@ void AppendToTripletList_r_wrp(int *ih_this, const int *index_column,
 void SetTripletAt_r_wrp(int *ih_this, const int *index, const int *index_column,
                         const int *index_row, const double *point_value);
 void GetTripletAt_r_wrp(const int *ih_this, const int *index, int *index_column,
-                        const int *index_row, double *point_value);
+                        int *index_row, double *point_value);
 void DestructTripletList_r_wrp(int *ih_this);
 void SortTripletList_r_wrp(const int *ih_this, const int *matrix_size,
                            int *h_sorted);
@@ -24,7 +24,7 @@ void SetTripletAt_c_wrp(int *ih_this, const int *index, const int *index_column,
                         const int *index_row, const double *point_value_real,
                         const double *point_value_imag);
 void GetTripletAt_c_wrp(const int *ih_this, const int *index, int *index_column,
-                        const int *index_row, const double *point_value_real,
+                        int *index_row, const double *point_value_real,
                         const double *point_value_imag);
 void DestructTripletList_c_wrp(int *ih_this);
 void SortTripletList_c_wrp(const int *ih_this, const int *matrix_size,

Source/CPlusPlus/EigenBounds.h

@@ -11,7 +11,7 @@ class Matrix_ps;
 class EigenBounds : public SolverBase {
 public:
   //! Compute a bounds on the minimum and maximum eigenvalue of a matrix.
-  //! Uses Gershgorin's theorem.
+  //! Uses Gershgorin theorem.
   //!\param matrix the matrix to compute the min/max of.
   //!\param min_ger_eig a lower bound on the eigenspectrum.
   //!\param max_ger_eig an uppder bound on the eigenspectrum.

Source/CPlusPlus/InverseSolvers.h

@@ -11,7 +11,7 @@ class Matrix_ps;
 class InverseSolvers : public SolverBase {
 public:
   //! Compute the inverse of a matrix.
-  //! An implementation of Hotelling's method.
+  //! An implementation of Hotelling method.
   //!\param Overlap the matrix to invert.
   //!\param InverseMat = Overlap^-1.
   //!\param solver_parameters parameters for the solver
@@ -24,7 +24,7 @@ class InverseSolvers : public SolverBase {
   static void DenseInvert(const Matrix_ps &Overlap, Matrix_ps &InverseMat,
                           const SolverParameters &solver_parameters);
   //! Compute the pseudoinverse of a matrix.
-  //! An implementation of Hotelling's method, with a different convergence
+  //! An implementation of Hotelling method, with a different convergence
   //! criteria.
   //!\param Overlap the matrix to invert.
   //!\param InverseMat = Overlap^-1.

Source/CPlusPlus/Logging.cc

@@ -13,7 +13,7 @@ void NTPoly::ActivateLogger(bool start_document) {
 
 ////////////////////////////////////////////////////////////////////////////////
 void NTPoly::ActivateLogger(const string file_name, bool start_document) {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   string temp = file_name;
   ActivateLoggerFile_wrp(&start_document, &temp.c_str()[0], &string_length);
 }

Source/CPlusPlus/PSMatrix.cc

@@ -27,7 +27,7 @@ Matrix_ps::Matrix_ps(int matrix_dimension, const ProcessGrid &grid) {
 
 //////////////////////////////////////////////////////////////////////////////
 Matrix_ps::Matrix_ps(std::string file_name, bool is_binary) {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   if (is_binary) {
     ConstructMatrixFromBinary_ps_wrp(ih_this, &file_name.c_str()[0],
                                      &string_length);
@@ -40,7 +40,7 @@ Matrix_ps::Matrix_ps(std::string file_name, bool is_binary) {
 //////////////////////////////////////////////////////////////////////////////
 Matrix_ps::Matrix_ps(std::string file_name, const ProcessGrid &grid,
                      bool is_binary) {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   if (is_binary) {
     ConstructMatrixFromBinaryPG_ps_wrp(ih_this, &file_name.c_str()[0],
                                        &string_length, grid.ih_this);
@@ -61,13 +61,13 @@ Matrix_ps::Matrix_ps(const Matrix_ps &matB) {
 
 //////////////////////////////////////////////////////////////////////////////
 void Matrix_ps::WriteToBinary(std::string file_name) const {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   WriteMatrixToBinary_ps_wrp(ih_this, &file_name.c_str()[0], &string_length);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 void Matrix_ps::WriteToMatrixMarket(string file_name) const {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   WriteMatrixToMatrixMarket_ps_wrp(ih_this, &file_name.c_str()[0],
                                    &string_length);
 }

Source/CPlusPlus/Permutation.cc

@@ -9,9 +9,9 @@ extern "C" {
 ////////////////////////////////////////////////////////////////////////////////
 namespace NTPoly {
 ////////////////////////////////////////////////////////////////////////////////
-Permutation::Permutation(int matrix_dimension) {
+Permutation::Permutation(int dimension) {
   was_filled = false;
-  this->matrix_dimension = matrix_dimension;
+  this->matrix_dimension = dimension;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

Source/CPlusPlus/Polynomial.h

@@ -23,13 +23,13 @@ class Polynomial : public SolverBase {
   void SetCoefficient(int degree, double coefficient);
 
 public:
-  //! Compute A Matrix Polynomial Using Horner's Method.
+  //! Compute A Matrix Polynomial Using Horner Method.
   //!\param InputMat input matrix.
   //!\param OutputMat = p(InputMat)
   //!\param solver_parameters parameters for the solver
   void HornerCompute(const Matrix_ps &InputMat, Matrix_ps &OutputMat,
                      const SolverParameters &solver_parameters) const;
-  //! Compute A Matrix Polynomial Using Paterson and Stockmeyer's Method.
+  //! Compute A Matrix Polynomial Using Paterson and Stockmeyer Method.
   //!\param InputMat input matrix.
   //!\param OutputMat = p(InputMat)
   //!\param solver_parameters parameters for the solver

Source/CPlusPlus/ProcessGrid.h

@@ -1,6 +1,12 @@
 #ifndef PROCESSGRID_h
 #define PROCESSGRID_h
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wcast-function-type"
+#pragma GCC diagnostic ignored "-Wuseless-cast"
+#pragma GCC diagnostic ignored "-Wold-style-cast"
 #include <mpi.h>
+#pragma GCC diagnostic pop
 
 #include "Wrapper.h"
 

Source/CPlusPlus/SMatrix.cc

@@ -21,12 +21,12 @@ Matrix_lsc::Matrix_lsc(int columns, int rows) {
 
 ////////////////////////////////////////////////////////////////////////////////
 Matrix_lsr::Matrix_lsr(std::string file_name) {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   ConstructMatrixFromFile_lsr_wrp(ih_this, &file_name.c_str()[0],
                                   &string_length);
 }
 Matrix_lsc::Matrix_lsc(std::string file_name) {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   ConstructMatrixFromFile_lsc_wrp(ih_this, &file_name.c_str()[0],
                                   &string_length);
 }
@@ -193,12 +193,12 @@ void Matrix_lsc::Print() const { PrintMatrix_lsc_wrp(ih_this); }
 
 ////////////////////////////////////////////////////////////////////////////////
 void Matrix_lsr::WriteToMatrixMarket(string file_name) const {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   PrintMatrixF_lsr_wrp(ih_this, &file_name.c_str()[0], &string_length);
 }
 
 void Matrix_lsc::WriteToMatrixMarket(string file_name) const {
-  int string_length = file_name.length();
+  int string_length = static_cast<int>(file_name.length());
   PrintMatrixF_lsc_wrp(ih_this, &file_name.c_str()[0], &string_length);
 }
 

Source/Fortran/CholeskySolversModule.F90

@@ -79,7 +79,7 @@ SUBROUTINE BroadcastVector_r(num_values, indices, values, root, comm)
     !> Root from which we broadcast.
     INTEGER, INTENT(IN) :: root
     !> Communicator to broadcast along.
-    INTEGER, INTENT(INOUT) :: comm
+    INTEGER, INTENT(IN) :: comm
     !! Local
     INTEGER :: err
 
@@ -153,7 +153,7 @@ SUBROUTINE DotAllHelper_r(num_values_i, indices_i, values_i, num_values_j, &
     !> The dot product values for each vector j.
     REAL(NTREAL), DIMENSION(:), INTENT(OUT) :: out_values
     !> The communicator to reduce along.
-    INTEGER, INTENT(INOUT) :: comm
+    INTEGER, INTENT(IN) :: comm
 
 #include "solver_includes/DotAllHelper.f90"
 

Source/Fortran/ConvergenceMonitorModule.F90

@@ -1,9 +1,9 @@
 !> A module for monitoring convergence of an iterative algorithim.
-!! In basic mode, we monitor that the last value isn't below the tight cutoff.
+!! In basic mode, we monitor that the last value is not below the tight cutoff.
 !! In automatic mode we monitor the following conditions:
-!! o The last value can't be negative
+!! o The last value can not be negative
 !! o The moving average is within an order of magnitude
-!! o The value isn't above the loose cutoff
+!! o The value is not above the loose cutoff
 MODULE ConvergenceMonitor
   USE DataTypesModule, ONLY : NTREAL
   USE LoggingModule, ONLY : EnterSubLog, ExitSubLog, WriteElement, &
@@ -18,7 +18,7 @@ MODULE ConvergenceMonitor
      REAL(NTREAL), DIMENSION(:), ALLOCATABLE :: win_long
      !> The number of values that have been added
      INTEGER :: nval
-     !> We aren't converged if the average isn't below this.
+     !> We are not converged if the average is not below this.
      REAL(NTREAL) :: loose_cutoff
      !> We definitely are converged if the last value is below this.
      REAL(NTREAL) :: tight_cutoff
@@ -40,7 +40,7 @@ PURE SUBROUTINE ConstructMonitor(this, short_len_in, long_len_in, &
     INTEGER, INTENT(IN), OPTIONAL :: short_len_in
     !> The length of the long window (default: 6)
     INTEGER, INTENT(IN), OPTIONAL :: long_len_in
-    !> If the average is greater than this than we aren't 
+    !> If the average is greater than this than we are not
     !! converged (default: 0.01)
     REAL(NTREAL), INTENT(IN), OPTIONAL :: loose_cutoff_in
     !> If the last value is less than this, we definitely are converged 
@@ -149,7 +149,7 @@ FUNCTION CheckConverged(this, be_verbose) RESULT(conv)
     !! Automatic disabled
     conv = .TRUE.
 
-    !! First check that we've seen enough values to make a judgement.
+    !! First check that we have seen enough values to make a judgement.
     IF (this%nval .LT. SIZE(this%win_long)) conv = .FALSE.
 
     !! Compute Averages

Source/Fortran/EigenBoundsModule.F90

@@ -135,7 +135,7 @@ SUBROUTINE PowerBounds(this, max_value, solver_parameters_in)
        CALL ScaleMatrix(vector2, scale_value)
        CALL CopyMatrix(vector2, vector)
 
-       !! Aitken's Extrapolation
+       !! Aitken Extrapolation
        ritz_values(1) = ritz_values(2)
        ritz_values(2) = ritz_values(3)
        ritz_values(3) = max_value
@@ -154,7 +154,7 @@ SUBROUTINE PowerBounds(this, max_value, solver_parameters_in)
           aitken_values(3) = ritz_values(3)
        END IF
 
-       !! Check if Converged - pass the negative value because we're looking
+       !! Check if Converged - pass the negative value because we are looking
        !! for the largest eigenvalue value.
        CALL AppendValue(params%monitor,  &
             & - (aitken_values(3) - aitken_values(2)))

Source/Fortran/EigenExaModule.F90

@@ -164,7 +164,7 @@ END SUBROUTINE EigenExa_c
 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
   !> Setup the eigen exa data structures.
   SUBROUTINE InitializeEigenExa(A, nvals, eigenvectors, exa)
-    !> The matrix we're working on.
+    !> The matrix we are working on.
     TYPE(Matrix_ps), INTENT(IN) :: A
     !> Number of eigenvalues to compute.
     INTEGER, INTENT(IN) :: nvals

Source/Fortran/FermiOperatorModule.F90

@@ -522,7 +522,7 @@ SUBROUTINE ComputeX(W, I, pool, threshold, Out, W2_out)
     REAL(NTREAL), INTENT(IN) :: threshold
     !> The result matrix.
     TYPE(Matrix_ps), INTENT(INOUT) :: Out
-    !> If you want the wave operator's square
+    !> If you want square of the wave operator
     TYPE(Matrix_ps), INTENT(INOUT), OPTIONAL :: W2_out
     !! Local matrices.
     TYPE(Matrix_ps) :: W2, Temp