Rename check_correctness function

test/C/driver/legacy_interface/legacy_complex_driver_c_version.c

@@ -274,7 +274,7 @@ int main(int argc, char** argv) {
    }
 
    /* check the results */
-   status = check_correctness_complex_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_complex_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 
    if (status !=0){
      printf("The computed EVs are not correct !\n");

test/C/driver/legacy_interface/legacy_real_driver_c_version.c

@@ -278,7 +278,7 @@ int main(int argc, char** argv) {
 
 
    /* check the results */
-   status = check_correctness_real_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_real_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 
    if (status !=0){
      printf("The computed EVs are not correct !\n");

test/C/driver/legacy_interface/legacy_single_complex_driver_c_version.c

@@ -274,7 +274,7 @@ int main(int argc, char** argv) {
    }
 
    /* check the results */
-   status = check_correctness_complex_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_complex_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 
    if (status !=0){
      printf("The computed EVs are not correct !\n");

test/C/driver/legacy_interface/legacy_single_real_driver_c_version.c

@@ -277,7 +277,7 @@ int main(int argc, char** argv) {
    }
 
    /* check the results */
-   status = check_correctness_real_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_real_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 
    if (status !=0){
      printf("The computed EVs are not correct !\n");

test/C/elpa1/legacy_interface/legacy_complex_1stage_c_version.c

@@ -241,9 +241,9 @@ int main(int argc, char** argv) {
 
    /* check the results */
 #ifdef DOUBLE_PRECISION_COMPLEX
-   status = check_correctness_complex_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_complex_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #else
-   status = check_correctness_complex_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_complex_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #endif
 
    if (status !=0){

test/C/elpa1/legacy_interface/legacy_real_1stage_c_version.c

@@ -233,9 +233,9 @@ int main(int argc, char** argv) {
 
 #ifdef DOUBLE_PRECISION_REAL
    /* check the results */
-   status = check_correctness_real_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_real_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #else
-   status = check_correctness_real_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_real_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #endif
    if (status !=0){
      printf("The computed EVs are not correct !\n");

test/C/elpa2/legacy_interface/legacy_complex_2stage_c_version.c

@@ -236,9 +236,9 @@ int main(int argc, char** argv) {
 
    /* check the results */
 #ifdef DOUBLE_PRECISION_COMPLEX
-   status = check_correctness_complex_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_complex_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #else
-   status = check_correctness_complex_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_complex_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #endif
    if (status !=0){
      printf("The computed EVs are not correct !\n");

test/C/elpa2/legacy_interface/legacy_real_2stage_c_version.c

@@ -230,9 +230,9 @@ int main(int argc, char** argv) {
 
    /* check the results */
 #ifdef DOUBLE_PRECISION_REAL
-   status = check_correctness_real_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_real_double_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #else
-   status = check_correctness_real_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
+   status = check_correctness_evp_numeric_residuals_real_single_f(na, nev, na_rows, na_cols, as, z, ev, sc_desc, myid);
 #endif
 
    if (status !=0){

test/Fortran/driver/legacy_interface/legacy_complex_driver.F90

@@ -323,7 +323,7 @@ program test_complex2
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/driver/legacy_interface/legacy_real_driver.F90

@@ -315,7 +315,7 @@ program test_real2
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/driver/legacy_interface/legacy_single_complex_driver.F90

@@ -323,7 +323,7 @@ program test_complex2
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/driver/legacy_interface/legacy_single_real_driver.F90

@@ -314,7 +314,7 @@ program test_real2
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_complex.F90

@@ -271,7 +271,7 @@ program test_complex_double_precision
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
 
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_complex_gpu.F90

@@ -270,7 +270,7 @@ program test_complex_gpu_version_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_real.F90

@@ -264,7 +264,7 @@ program test_real_double_precision
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
 
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_real_gpu.F90

@@ -264,7 +264,7 @@ program test_real_gpu_version_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_single_complex.F90

@@ -270,7 +270,7 @@ program test_complex_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_single_complex_gpu.F90

@@ -270,7 +270,7 @@ program test_complex_gpu_version_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_single_real.F90

@@ -263,7 +263,7 @@ program test_real_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_single_real_gpu.F90

@@ -264,7 +264,7 @@ program test_real_gpu_version_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_single_toeplitz.F90

@@ -326,7 +326,7 @@ program test_solve_tridi_single
    endif
 
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, a, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, a, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa1/legacy_interface/legacy_toeplitz.F90

@@ -327,7 +327,7 @@ program test_solve_tridi
    endif
 
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, a, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, a, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
 

test/Fortran/elpa2/complex_2stage_banded.F90

@@ -253,7 +253,7 @@ program test_complex2_double_banded
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/double_instance.F90

@@ -193,14 +193,14 @@ program test_interface
    call elpa_deallocate(e2)
    call elpa_uninit()
 
-   status = check_correctness(na, nev, as1, z1, ev1, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as1, z1, ev1, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a1)
    deallocate(as1)
    deallocate(z1)
    deallocate(ev1)
 
-   status = check_correctness(na, nev, as2, z2, ev2, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as2, z2, ev2, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a2)
    deallocate(as2)

test/Fortran/elpa2/legacy_interface/legacy_complex.F90

@@ -265,7 +265,7 @@ program test_complex2_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_complex_api.F90

@@ -397,7 +397,7 @@ program test_complex2_choose_kernel_with_api_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_complex_default_kernel.F90

@@ -293,7 +293,7 @@ program test_complex2_default_kernel_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_complex_gpu.F90

@@ -292,7 +292,7 @@ program test_complex2_gpu_version_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_real.F90

@@ -270,7 +270,7 @@ program test_real2_double_precision
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
 
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_real_api.F90

@@ -432,7 +432,7 @@ program test_real2_choose_kernel_with_api_double_precision
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
 
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_real_default_kernel.F90

@@ -290,7 +290,7 @@ program test_real2_default_kernel_double_precision
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
 
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_real_gpu.F90

@@ -291,7 +291,7 @@ program test_real2_gpu_version_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_real_qr.F90

@@ -334,7 +334,7 @@ program test_real2_default_kernel_qr_decomposition_double_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   ret = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   ret = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_complex.F90

@@ -264,7 +264,7 @@ program test_complex2_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_complex_api.F90

@@ -397,7 +397,7 @@ program test_complex2_choose_kernel_with_api_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_complex_default_kernel.F90

@@ -290,7 +290,7 @@ program test_complex2_default_kernel_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_complex_gpu.F90

@@ -289,7 +289,7 @@ program test_complex2_gpu_version_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_real.F90

@@ -269,7 +269,7 @@ program test_real2_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_real_api.F90

@@ -428,7 +428,7 @@ program test_real2_choose_kernel_with_api_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_real_default_kernel.F90

@@ -289,7 +289,7 @@ program test_real2_default_kernel_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_real_gpu.F90

@@ -292,7 +292,7 @@ program test_real2_gpu_version_single_precision
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
 
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/legacy_interface/legacy_single_real_qr.F90

@@ -338,7 +338,7 @@ program test_real2_default_kernel_qr_decomposition_single_precision
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   ret = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   ret = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/real_2stage_banded.F90

@@ -250,7 +250,7 @@ program test_real2_double_banded
    ! Test correctness of result (using plain scalapack routines)
 
    
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
 
    deallocate(a)

test/Fortran/elpa2/single_complex_2stage_banded.F90

@@ -252,7 +252,7 @@ program test_complex2_single_banded
 
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
 
    deallocate(a)
    deallocate(as)

test/Fortran/elpa2/single_real_2stage_banded.F90

@@ -248,7 +248,7 @@ program test_real2_single_banded
    !-------------------------------------------------------------------------------
    ! Test correctness of result (using plain scalapack routines)
 
-   status = check_correctness(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
+   status = check_correctness_evp_numeric_residuals(na, nev, as, z, ev, sc_desc, nblk, myid, np_rows, np_cols, my_prow, my_pcol)
    deallocate(a)
    deallocate(as)
 

test/Fortran/elpa_tests.F90

@@ -1013,10 +1013,10 @@ program test_all_real
 
 
      if (input_options%datatype .eq. 1) then
-       status = check_correctness(na, nev, as_real, z_real, ev, sc_desc, myid)
+       status = check_correctness_evp_numeric_residuals(na, nev, as_real, z_real, ev, sc_desc, myid)
      endif
      if (input_options%datatype .eq. 2) then
-       status = check_correctness(na, nev, as_complex, z_complex, ev, sc_desc, myid)
+       status = check_correctness_evp_numeric_residuals(na, nev, as_complex, z_complex, ev, sc_desc, myid)
      endif
 
      if (status .eq. 1) then
@@ -1099,7 +1099,7 @@ program test_all_real
                         elpa_int_value_to_string("real_kernel", ELPA_2STAGE_REAL_DEFAULT),' default kernel:',tEnd - tStart
          if (myid == 0) print *," "
 
-         status = check_correctness(na, nev, as_real, z_real, ev, sc_desc, myid)
+         status = check_correctness_evp_numeric_residuals(na, nev, as_real, z_real, ev, sc_desc, myid)
          if (myid == 0) print *," "
 
          if (status .eq. 1) then
@@ -1189,7 +1189,7 @@ program test_all_real
                             trim(elpa_real_kernel_name(this_kernel)),' kernel:',tEnd - tStart
              if (myid == 0) print *," "
 
-             status = check_correctness(na, nev, as_real, z_real, ev, sc_desc, myid)
+             status = check_correctness_evp_numeric_residuals(na, nev, as_real, z_real, ev, sc_desc, myid)
              if (myid == 0) print *," "
 
              if (status .eq. 1) then
@@ -1283,7 +1283,7 @@ program test_all_real
                           trim(elpa_real_kernel_name(input_options%this_real_kernel)),' kernel:',tEnd - tStart
            if (myid == 0) print *," "
 
-           status = check_correctness(na, nev, as_real, z_real, ev, sc_desc, myid)
+           status = check_correctness_evp_numeric_residuals(na, nev, as_real, z_real, ev, sc_desc, myid)
            if (myid == 0) print *," "
 
            if (status .eq. 1) then
@@ -1380,7 +1380,7 @@ program test_all_real
                         elpa_int_value_to_string("complex_kernel", ELPA_2STAGE_COMPLEX_DEFAULT),' default kernel:',tEnd - tStart
          if (myid == 0) print *," "
 
-         status = check_correctness(na, nev, as_complex, z_complex, ev, sc_desc, myid)
+         status = check_correctness_evp_numeric_residuals(na, nev, as_complex, z_complex, ev, sc_desc, myid)
          if (myid == 0) print *," "
 
          if (status .eq. 1) then
@@ -1471,7 +1471,7 @@ program test_all_real
                               trim(elpa_complex_kernel_name(this_kernel)),' kernel:',tEnd - tStart
              if (myid == 0) print *," "
 
-             status = check_correctness(na, nev, as_complex, z_complex, ev, sc_desc, myid)
+             status = check_correctness_evp_numeric_residuals(na, nev, as_complex, z_complex, ev, sc_desc, myid)
              if (myid == 0) print *," "
 
              if (status .eq. 1) then
@@ -1568,7 +1568,7 @@ program test_all_real
                           trim(elpa_complex_kernel_name(input_options%this_complex_kernel)),' kernel:',tEnd - tStart
            if (myid == 0) print *," "
 
-           status = check_correctness(na,