amd/blis
1
0
Fork 0
mirror of https://github.com/amd/blis.git synced 2026-04-19 23:28:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

GTestSuite: Misc fixes

Browse Source 
- Move asumv and nrm2 testinghelpers files from util to level1 (missed in
  commit 0923d8ff56)
- Correct spelling mistakes and references to incorrect arguments in
  comments in various files
- Correct comments listing invalid input tests in syr_IIT_ERS.cpp and
  her_IIT_ERS.cpp
- Fix incorrect use of M in symv_IIT_ERS.cpp and hemv_IIT_ERS.cpp

AMD-Internal: [CPUPL-7386]
This commit is contained in:
Smyth, Edward
2025-12-05 17:23:47 +00:00
committed by GitHub
parent b04818bf48
commit eff1b561c5
41 changed files with 117 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

0
gtestsuite/testinghelpers/inc/util/ref_asumv.h → gtestsuite/testinghelpers/inc/level1/ref_asumv.h
View File

0
gtestsuite/testinghelpers/inc/util/ref_nrm2.h → gtestsuite/testinghelpers/inc/level1/ref_nrm2.h
View File

2
gtestsuite/testinghelpers/src/util/ref_asumv.cpp → gtestsuite/testinghelpers/src/level1/ref_asumv.cpp
View File

@@ -33,7 +33,7 @@
*/
#include "blis.h"
#include "util/ref_asumv.h"
#include "level1/ref_asumv.h"
/*
* ==========================================================================

2
gtestsuite/testinghelpers/src/util/ref_nrm2.cpp → gtestsuite/testinghelpers/src/level1/ref_nrm2.cpp
View File

@@ -33,7 +33,7 @@
*/
#include "blis.h"
#include "util/ref_nrm2.h"
#include "level1/ref_nrm2.h"
/*
* ==========================================================================

10
gtestsuite/testsuite/level1/asumv/asumv.h
View File

@@ -61,7 +61,7 @@ static RT asumv_(gtint_t n, T* x, gtint_t incx){
else if constexpr (std::is_same<T, dcomplex>::value)
return dzasum_( &n, x, &incx );
else
throw std::runtime_error("Error in testsuite/util/asumv.h: Invalid typename in asumv_().");
throw std::runtime_error("Error in testsuite/level1/asumv.h: Invalid typename in asumv_().");
}
template<typename T, typename RT = typename testinghelpers::type_info<T>::real_type>
@@ -75,7 +75,7 @@ static RT asumv_blis_impl(gtint_t n, T* x, gtint_t incx){
else if constexpr (std::is_same<T, dcomplex>::value)
return dzasum_blis_impl( &n, x, &incx );
else
throw std::runtime_error("Error in testsuite/util/asumv.h: Invalid typename in asumv_blis_impl().");
throw std::runtime_error("Error in testsuite/level1/asumv.h: Invalid typename in asumv_blis_impl().");
}
template<typename T, typename RT = typename testinghelpers::type_info<T>::real_type>
@@ -89,7 +89,7 @@ static RT cblas_asumv(gtint_t n, T* x, gtint_t incx){
else if constexpr (std::is_same<T, dcomplex>::value)
return cblas_dzasum( n, x, incx );
else
throw std::runtime_error("Error in testsuite/util/asumv.h: Invalid typename in cblas_asumv().");
throw std::runtime_error("Error in testsuite/level1/asumv.h: Invalid typename in cblas_asumv().");
}
template<typename T, typename RT = typename testinghelpers::type_info<T>::real_type>
@@ -104,7 +104,7 @@ static RT typed_asumv(gtint_t n, T* x, gtint_t incx){
else if constexpr (std::is_same<T, dcomplex>::value)
bli_zasumv(n, x, incx, &asum);
else
throw std::runtime_error("Error in testsuite/util/asumv.h: Invalid typename in cblas_asumv().");
throw std::runtime_error("Error in testsuite/level1/asumv.h: Invalid typename in cblas_asumv().");
return asum;
}
@@ -136,7 +136,7 @@ static RT asumv(gtint_t n, T* x, gtint_t incx)
#elif TEST_BLIS_TYPED
return typed_asumv<T>(n, x, incx);
#else
throw std::runtime_error("Error in testsuite/util/asumv.h: No interfaces are set to be tested.");
throw std::runtime_error("Error in testsuite/level1/asumv.h: No interfaces are set to be tested.");
#endif
#ifdef TEST_INPUT_ARGS

2
gtestsuite/testsuite/level1/asumv/test_asumv.h
View File

@@ -36,7 +36,7 @@
#include "asumv.h"
#include <limits>
#include "util/ref_asumv.h"
#include "level1/ref_asumv.h"
#include "inc/check_error.h"
/**

2
gtestsuite/testsuite/level1/axpyf/test_axpyf.h
View File

@@ -66,7 +66,7 @@ static void test_axpyf(
gtint_t lda = testinghelpers::get_leading_dimension( 'c', 'n', m, b, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
std::vector<T> A = testinghelpers::get_random_matrix<T>( -2, 8, 'c', 'n', m, b, lda );

2
gtestsuite/testsuite/level1/dotxf/test_dotxf.h
View File

@@ -62,7 +62,7 @@ static void test_dotxf(
gtint_t lda = testinghelpers::get_leading_dimension( 'c', 'n', m, b, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
std::vector<T> A = testinghelpers::get_random_matrix<T>( -2, 8, 'c', 'n', m, b, lda );

2
gtestsuite/testsuite/level1/nrm2/test_nrm2.h
View File

@@ -36,7 +36,7 @@
#include "nrm2.h"
#include <limits>
#include "util/ref_nrm2.h"
#include "level1/ref_nrm2.h"
#include "inc/check_error.h"
#include "inc/data_pool.h"

28
gtestsuite/testsuite/level2/gemv/IIT_ERS/gemv_IIT_ERS.cpp
View File

@@ -73,7 +73,7 @@ TYPED_TEST(gemv_IIT_ERS, invalid_storage)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -141,7 +141,7 @@ TYPED_TEST(gemv_IIT_ERS, invalid_trans)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -193,7 +193,7 @@ TYPED_TEST(gemv_IIT_ERS, m_lt_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -245,7 +245,7 @@ TYPED_TEST(gemv_IIT_ERS, n_lt_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -297,7 +297,7 @@ TYPED_TEST(gemv_IIT_ERS, invalid_lda)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -349,7 +349,7 @@ TYPED_TEST(gemv_IIT_ERS, incx_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -401,7 +401,7 @@ TYPED_TEST(gemv_IIT_ERS, incy_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -462,7 +462,7 @@ TYPED_TEST(gemv_IIT_ERS, m_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -514,7 +514,7 @@ TYPED_TEST(gemv_IIT_ERS, n_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -567,7 +567,7 @@ TYPED_TEST(gemv_IIT_ERS, m_eq_zero_Unitbeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -615,7 +615,7 @@ TYPED_TEST(gemv_IIT_ERS, n_eq_zero_UnitAlphaBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -662,7 +662,7 @@ TYPED_TEST(gemv_IIT_ERS, ZeroAlpha_UnitBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -718,7 +718,7 @@ TYPED_TEST(gemv_IIT_ERS, ZeroAlpha_ZeroBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, M, incx );
@@ -753,7 +753,7 @@ TYPED_TEST(gemv_IIT_ERS, ZeroAlpha_OtherBeta)
double thresh = testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, TRANS, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, M, incx );

4
gtestsuite/testsuite/level2/ger/test_ger.h
View File

@@ -49,7 +49,7 @@ void test_ger( char storage, char conjx, char conjy, gtint_t m, gtint_t n,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', m, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(m, n, incx);
@@ -92,7 +92,7 @@ void test_ger( char storage, char conjx, char conjy, gtint_t m, gtint_t n,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', m, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(n, incy, m);

48
gtestsuite/testsuite/level2/hemv/IIT_ERS/hemv_IIT_ERS.cpp
View File

@@ -73,9 +73,9 @@ TYPED_TEST(hemv_IIT_ERS, invalid_storage)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -140,9 +140,9 @@ TYPED_TEST(hemv_IIT_ERS, invalid_UPLO)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -192,9 +192,9 @@ TYPED_TEST(hemv_IIT_ERS, n_lt_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -244,9 +244,9 @@ TYPED_TEST(hemv_IIT_ERS, invalid_lda)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -296,9 +296,9 @@ TYPED_TEST(hemv_IIT_ERS, incx_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -348,9 +348,9 @@ TYPED_TEST(hemv_IIT_ERS, incy_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -409,9 +409,9 @@ TYPED_TEST(hemv_IIT_ERS, n_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -457,9 +457,9 @@ TYPED_TEST(hemv_IIT_ERS, n_eq_zero_UnitAlphaBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -504,9 +504,9 @@ TYPED_TEST(hemv_IIT_ERS, ZeroAlpha_UnitBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 1, 3, N, incy );
@@ -560,10 +560,10 @@ TYPED_TEST(hemv_IIT_ERS, ZeroAlpha_ZeroBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, M, incx );
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, N, incx );
//----------------------------------------------------------
// Call BLIS function
@@ -595,10 +595,10 @@ TYPED_TEST(hemv_IIT_ERS, ZeroAlpha_OtherBeta)
double thresh = testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, M, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, M, incx );
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 0, 1, N, incy );
std::vector<T> y_ref(y);
std::vector<T> y2(y);

2
gtestsuite/testsuite/level2/hemv/test_hemv.h
View File

@@ -49,7 +49,7 @@ void test_hemv( char storage, char uploa, char conja, char conjx, gtint_t n,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(n, incy, incx);

11
gtestsuite/testsuite/level2/her/IIT_ERS/her_IIT_ERS.cpp
View File

@@ -77,7 +77,7 @@ TYPED_TEST(her_IIT_ERS, invalid_storage)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her with a invalid value for TRANS value for A.
// Call BLIS her with a invalid value for storage.
her<T>( 'x', UPLO, CONJ, N, &alpha, x.data(), incx, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -99,8 +99,7 @@ TYPED_TEST(her_IIT_ERS, invalid_storage)
1. When UPLO != 'U' || UPLO != 'L' (info = 1)
2. When n < 0 (info = 2)
3. When incx = 0 (info = 5)
4. When incy = 0 (info = 7)
5. When LDA < max(1, n) (info = 9)
4. When LDA < max(1, n) (info = 7)
*/
@@ -136,7 +135,7 @@ TYPED_TEST(her_IIT_ERS, invalid_uplo)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her with a invalid value for TRANS value for A.
// Call BLIS her with a invalid value for uplo.
her<T>( STORAGE, 'p', CONJ, N, &alpha, x.data(), incx, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -179,7 +178,7 @@ TYPED_TEST(her_IIT_ERS, n_lt_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her with a invalid value for m.
// Call BLIS her with a invalid value for n.
her<T>( STORAGE, UPLO, CONJ, -1, &alpha, x.data(), incx, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -222,7 +221,7 @@ TYPED_TEST(her_IIT_ERS, incx_eq_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her with a invalid value for lda.
// Call BLIS her with a invalid value for incx.
her<T>( STORAGE, UPLO, CONJ, N, &alpha, x.data(), 0, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);

2
gtestsuite/testsuite/level2/her/test_her.h
View File

@@ -48,7 +48,7 @@ void test_her( char storage, char uploa, char conjx, gtint_t n, Tr alpha,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( -2, 5, storage, 'n', n, n, lda );
std::vector<T> x = testinghelpers::get_random_vector<T>( -3, 3, n, incx );

10
gtestsuite/testsuite/level2/her2/IIT_ERS/her2_IIT_ERS.cpp
View File

@@ -77,7 +77,7 @@ TYPED_TEST(her2_IIT_ERS, invalid_storage)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her2 with a invalid value for TRANS value for A.
// Call BLIS her2 with a invalid value for storage.
her2<T>( 'x', UPLO, CONJ, CONJ, N, &alpha, x.data(), incx, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -137,7 +137,7 @@ TYPED_TEST(her2_IIT_ERS, invalid_uplo)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her2 with a invalid value for TRANS value for A.
// Call BLIS her2 with a invalid value for uplo.
her2<T>( STORAGE, 'p', CONJ, CONJ, N, &alpha, x.data(), incx, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -181,7 +181,7 @@ TYPED_TEST(her2_IIT_ERS, n_lt_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her2 with a invalid value for m.
// Call BLIS her2 with a invalid value for n.
her2<T>( STORAGE, UPLO, CONJ, CONJ, -1, &alpha, x.data(), incx, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -225,7 +225,7 @@ TYPED_TEST(her2_IIT_ERS, incx_eq_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her2 with a invalid value for lda.
// Call BLIS her2 with a invalid value for incx.
her2<T>( STORAGE, UPLO, CONJ, CONJ, N, &alpha, x.data(), 0, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -269,7 +269,7 @@ TYPED_TEST(her2_IIT_ERS, incy_eq_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS her2 with a invalid value for lda.
// Call BLIS her2 with a invalid value for incy.
her2<T>( STORAGE, UPLO, CONJ, CONJ, N, &alpha, x.data(), incx, y.data(), 0, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);

2
gtestsuite/testsuite/level2/her2/test_her2.h
View File

@@ -49,7 +49,7 @@ void test_her2( char storage, char uploa, char conjx, char conjy, gtint_t n,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(incx, n, incy);

26
gtestsuite/testsuite/level2/symv/IIT_ERS/symv_IIT_ERS.cpp
View File

@@ -73,7 +73,7 @@ TYPED_TEST(symv_IIT_ERS, invalid_storage)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -140,7 +140,7 @@ TYPED_TEST(symv_IIT_ERS, invalid_UPLO)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -192,7 +192,7 @@ TYPED_TEST(symv_IIT_ERS, n_lt_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -244,7 +244,7 @@ TYPED_TEST(symv_IIT_ERS, invalid_lda)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -296,7 +296,7 @@ TYPED_TEST(symv_IIT_ERS, incx_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -348,7 +348,7 @@ TYPED_TEST(symv_IIT_ERS, incy_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -409,7 +409,7 @@ TYPED_TEST(symv_IIT_ERS, n_eq_zero)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -457,7 +457,7 @@ TYPED_TEST(symv_IIT_ERS, n_eq_zero_UnitAlphaBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -504,7 +504,7 @@ TYPED_TEST(symv_IIT_ERS, ZeroAlpha_UnitBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 1, 3, N, incx );
@@ -560,10 +560,10 @@ TYPED_TEST(symv_IIT_ERS, ZeroAlpha_ZeroBeta)
// Test with all arguments correct except for the value we are choosing to test.
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, M, incx );
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, N, incx );
//----------------------------------------------------------
// Call BLIS function
@@ -595,10 +595,10 @@ TYPED_TEST(symv_IIT_ERS, ZeroAlpha_OtherBeta)
double thresh = testinghelpers::getEpsilon<T>();
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( 1, 5, STORAGE, UPLO, N, N, LDA);
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, M, incx );
std::vector<T> x = testinghelpers::get_random_vector<T>( 0, 1, N, incx );
std::vector<T> y = testinghelpers::get_random_vector<T>( 0, 1, N, incy );
std::vector<T> y_ref(y);
std::vector<T> y2(y);

2
gtestsuite/testsuite/level2/symv/test_symv.h
View File

@@ -48,7 +48,7 @@ void test_symv( char storage, char uploa, char conja, char conjx, gtint_t n,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( -2, 5, storage, 'n', n, n, lda );
testinghelpers::make_symm<T>( storage, uploa, n, a.data(), lda );

11
gtestsuite/testsuite/level2/syr/IIT_ERS/syr_IIT_ERS.cpp
View File

@@ -76,7 +76,7 @@ TYPED_TEST(syr_IIT_ERS, invalid_storage)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr with a invalid value for TRANS value for A.
// Call BLIS syr with a invalid value for storage.
syr<T>( 'x', UPLO, CONJ, N, &alpha, x.data(), incx, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -98,8 +98,7 @@ TYPED_TEST(syr_IIT_ERS, invalid_storage)
1. When UPLO != 'U' || UPLO != 'L' (info = 1)
2. When n < 0 (info = 2)
3. When incx = 0 (info = 5)
4. When incy = 0 (info = 7)
5. When LDA < max(1, n) (info = 9)
4. When LDA < max(1, n) (info = 7)
*/
@@ -134,7 +133,7 @@ TYPED_TEST(syr_IIT_ERS, invalid_uplo)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr with a invalid value for TRANS value for A.
// Call BLIS syr with a invalid value for uplo.
syr<T>( STORAGE, 'p', CONJ, N, &alpha, x.data(), incx, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -176,7 +175,7 @@ TYPED_TEST(syr_IIT_ERS, n_lt_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr with a invalid value for m.
// Call BLIS syr with a invalid value for n.
syr<T>( STORAGE, UPLO, CONJ, -1, &alpha, x.data(), incx, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -218,7 +217,7 @@ TYPED_TEST(syr_IIT_ERS, incx_eq_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr with a invalid value for lda.
// Call BLIS syr with a invalid value for incx.
syr<T>( STORAGE, UPLO, CONJ, N, &alpha, x.data(), 0, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);

2
gtestsuite/testsuite/level2/syr/test_syr.h
View File

@@ -48,7 +48,7 @@ void test_syr( char storage, char uploa, char conjx, gtint_t n, T alpha,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( -2, 5, storage, 'n', n, n, lda );
std::vector<T> x = testinghelpers::get_random_vector<T>( -3, 3, n, incx );

10
gtestsuite/testsuite/level2/syr2/IIT_ERS/syr2_IIT_ERS.cpp
View File

@@ -77,7 +77,7 @@ TYPED_TEST(syr2_IIT_ERS, invalid_storage)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr2 with a invalid value for TRANS value for A.
// Call BLIS syr2 with a invalid value for storage.
syr2<T>( 'x', UPLO, CONJ, CONJ, N, &alpha, x.data(), incx, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -137,7 +137,7 @@ TYPED_TEST(syr2_IIT_ERS, invalid_uplo)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr2 with a invalid value for TRANS value for A.
// Call BLIS syr2 with a invalid value for uplo.
syr2<T>( STORAGE, 'p', CONJ, CONJ, N, &alpha, x.data(), incx, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -181,7 +181,7 @@ TYPED_TEST(syr2_IIT_ERS, n_lt_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr2 with a invalid value for m.
// Call BLIS syr2 with a invalid value for n.
syr2<T>( STORAGE, UPLO, CONJ, CONJ, -1, &alpha, x.data(), incx, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -225,7 +225,7 @@ TYPED_TEST(syr2_IIT_ERS, incx_eq_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr2 with a invalid value for lda.
// Call BLIS syr2 with a invalid value for incx.
syr2<T>( STORAGE, UPLO, CONJ, CONJ, N, &alpha, x.data(), 0, y.data(), incy, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);
@@ -269,7 +269,7 @@ TYPED_TEST(syr2_IIT_ERS, incy_eq_zero)
// Copy so that we check that the elements of C are not modified.
std::vector<T> a_ref(a);
// Call BLIS syr2 with a invalid value for lda.
// Call BLIS syr2 with a invalid value for incy.
syr2<T>( STORAGE, UPLO, CONJ, CONJ, N, &alpha, x.data(), incx, y.data(), 0, a.data(), LDA );
// Use bitwise comparison (no threshold).
computediff<T>( "C", STORAGE, N, N, a.data(), a_ref.data(), LDA);

2
gtestsuite/testsuite/level2/syr2/test_syr2.h
View File

@@ -49,7 +49,7 @@ void test_syr2( char storage, char uploa, char conjx, char conjy, gtint_t n,
gtint_t lda = testinghelpers::get_leading_dimension( storage, 'n', n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(incx, n, incy);

6
gtestsuite/testsuite/level2/trmv/test_trmv.h
View File

@@ -63,7 +63,7 @@ void test_trmv(
gtint_t lda = testinghelpers::get_leading_dimension( storage, transa, n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
dim_t size_a = testinghelpers::matsize(storage, transa, n, n, lda) * sizeof(T);
@@ -79,7 +79,7 @@ void test_trmv(
T* a_ptr = (T*)(a.greenzone_1);
T* x_ptr = (T*)(x.greenzone_1);
// Make A matix diagonal dominant to make sure that algorithm doesn't diverge
// Make A matrix diagonally dominant to make sure that algorithm doesn't diverge
// This makes sure that the trmv problem is solvable
for ( dim_t a_dim = 0; a_dim < n; ++a_dim )
{
@@ -103,7 +103,7 @@ void test_trmv(
// skipped making A triangular
// A matrix being a non triangular matrix could be a better test
// because we are exepcted to read only from the upper or lower triangular
// because we are expected to read only from the upper or lower triangular
// part of the data, contents of the rest of the matrix should not change the
// result.
// testinghelpers::make_triangular<T>( storage, uploa, n, a_ptr, lda );

6
gtestsuite/testsuite/level2/trsv/test_trsv.h
View File

@@ -64,7 +64,7 @@ void test_trsv(
gtint_t lda = testinghelpers::get_leading_dimension( storage, transa, n, n, lda_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
dim_t size_a = testinghelpers::matsize(storage, transa, n, n, lda) * sizeof(T);
@@ -83,7 +83,7 @@ void test_trsv(
T* a_ptr = (T*)(a.greenzone_1);
T* x_ptr = (T*)(x.greenzone_1);
// Make A matix diagonal dominant to make sure that algorithm doesn't diverge
// Make A matrix diagonally dominant to make sure that algorithm doesn't diverge
// This makes sure that the TRSV problem is solvable
for ( dim_t a_dim = 0; a_dim < n; ++a_dim )
{
@@ -107,7 +107,7 @@ void test_trsv(
// skipped making A triangular
// A matrix being a non triangular matrix could be a better test
// because we are exepcted to read only from the upper or lower triangular
// because we are expected to read only from the upper or lower triangular
// part of the data, contents of the rest of the matrix should not change the
// result.
// testinghelpers::make_triangular<T>( storage, uploa, n, a_ptr, lda );

4
gtestsuite/testsuite/level3/gemm/test_gemm.h
View File

@@ -53,7 +53,7 @@ void test_gemm( char storage, char trnsa, char trnsb, gtint_t m, gtint_t n,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(m, n, k);
@@ -119,7 +119,7 @@ void test_gemm( char storage, char trnsa, char trnsb, gtint_t m, gtint_t n,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(m, n, k);

2
gtestsuite/testsuite/level3/gemm_compute/test_gemm_compute.h
View File

@@ -55,7 +55,7 @@ void test_gemm_compute( char storage, char trnsa, char trnsb, char pcka, char pc
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(m, n, k);

2
gtestsuite/testsuite/level3/gemmt/test_gemmt.h
View File

@@ -54,7 +54,7 @@ void test_gemmt( char storage, char uploc, char transa, char transb, gtint_t n,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', n, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
T *a_ptr, *b_ptr, *c_ptr;
dim_t size_a = testinghelpers::matsize(storage, transa, n, k, lda) * sizeof(T);

2
gtestsuite/testsuite/level3/hemm/test_hemm.h
View File

@@ -54,7 +54,7 @@ void test_hemm( char storage, char side, char uplo, char conja, char transb,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(m, n, ldc_inc);

2
gtestsuite/testsuite/level3/her2k/test_her2k.h
View File

@@ -52,7 +52,7 @@ void test_her2k( char storage, char uplo, char transa, char transb,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', n, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(n, k, ldb_inc);

2
gtestsuite/testsuite/level3/herk/test_herk.h
View File

@@ -51,7 +51,7 @@ void test_herk( char storage, char uplo, char transa, gtint_t n, gtint_t k,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', n, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(n, k, lda_inc);

2
gtestsuite/testsuite/level3/symm/test_symm.h
View File

@@ -54,7 +54,7 @@ void test_symm( char storage, char side, char uplo, char conja, char transb,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(m, n, ldc_inc);

2
gtestsuite/testsuite/level3/syr2k/test_syr2k.h
View File

@@ -52,7 +52,7 @@ void test_syr2k( char storage, char uplo, char transa, char transb, gtint_t n,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', n, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(n, k, lda_inc);

2
gtestsuite/testsuite/level3/syrk/test_syrk.h
View File

@@ -50,7 +50,7 @@ void test_syrk( char storage, char uplo, char transa, gtint_t n, gtint_t k,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', n, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random integer numbers.
// Initialize matrices with random integer numbers.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(n, k, lda_inc);

2
gtestsuite/testsuite/level3/trmm/test_trmm.h
View File

@@ -51,7 +51,7 @@ void test_trmm( char storage, char side, char uploa, char transa, char diaga,
gtint_t ldb = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldb_inc );
//----------------------------------------------------------
// Initialize matrics with random values.
// Initialize matrices with random values.
//----------------------------------------------------------
// Set index to a starting position for this test
get_pool<T>().set_index(m, n, ldb_inc);

2
gtestsuite/testsuite/level3/trmm3/test_trmm3.h
View File

@@ -52,7 +52,7 @@ void test_trmm3( char storage, char side, char uploa, char transa, char diaga,
gtint_t ldc = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldc_inc );
//----------------------------------------------------------
// Initialize matrics with random values.
// Initialize matrices with random values.
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( -2, 8, storage, transa, mn, mn, lda );
std::vector<T> b = testinghelpers::get_random_matrix<T>( -5, 2, storage, transb, m, n, ldb );

2
gtestsuite/testsuite/level3/trsm/test_trsm.h
View File

@@ -196,7 +196,7 @@ void test_trsm( char storage, char side, char uploa, char transa, char diaga,
gtint_t ldb = testinghelpers::get_leading_dimension( storage, 'n', m, n, ldb_inc );
//----------------------------------------------------------
// Initialize matrics with random values.
// Initialize matrices with random values.
//----------------------------------------------------------
std::vector<T> a( testinghelpers::matsize(storage, transa, mn, mn, lda) );
std::vector<T> b( testinghelpers::matsize(storage, 'n', m, n, ldb) );

2
gtestsuite/testsuite/ukr/gemm/dgemm/dgemm_ukernel.cpp
View File

@@ -842,7 +842,7 @@ TEST_P( dgemmGenericSmall, gemm_small)
else
{
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( -2, 8, storageC, 'n', m, k, lda );
std::vector<T> b = testinghelpers::get_random_matrix<T>( -5, 2, storageC, 'n', k, n, ldb );

2
gtestsuite/testsuite/ukr/gemm/sgemm/sgemm_ukernel.cpp
View File

@@ -610,7 +610,7 @@ TEST_P( sgemmGenericSmallTest, gemm_small)
gtint_t ldc = testinghelpers::get_leading_dimension( storageC, 'n', m, n, 0 );
//----------------------------------------------------------
// Initialize matrics with random numbers
// Initialize matrices with random numbers
//----------------------------------------------------------
std::vector<T> a = testinghelpers::get_random_matrix<T>( -2, 8, storageC, 'n', m, k, lda );
std::vector<T> b = testinghelpers::get_random_matrix<T>( -5, 2, storageC, 'n', k, n, ldb );

2
gtestsuite/testsuite/ukr/nrm2/test_nrm2_ukr.h
View File

@@ -36,7 +36,7 @@
#include "level1/nrm2/nrm2.h"
#include <limits>
#include "util/ref_nrm2.h"
#include "level1/ref_nrm2.h"
#include "inc/check_error.h"
// Defining the function pointer type for ?norm2fv vectorized kernels

10
gtestsuite/testsuite/ukr/trsm/test_trsm_ukr.h
View File

@@ -148,11 +148,11 @@ static void test_trsm_ukr( FT ukr_fp, char storage, char uploa, char diaga,
}
}
// Make A11 diagonal dominant in order to make sure that
// input matrics are solvable
// Make A11 diagonally dominant in order to make sure that
// input matrices are solvable
// In case BLIS_ENABLE_TRSM_PREINVERSION is enabled,
// diagonal elements of A11 have to be inverted twice,
// once for making it diagonal dominant, and once for packing with
// once for making it diagonally dominant, and once for packing with
// inversion, inverting it twice is equivalent to not inverting it at all.
// Therefore, in case of BLIS_ENABLE_TRSM_PREINVERSION, diagonal elements
// of A11 are not inverted.
@@ -366,8 +366,8 @@ static void test_trsm_small_ukr( FT ukr_fp, char side, char uploa, char diaga,
// make A triangular
testinghelpers::make_triangular<T>( 'c', uploa, mn0_a, a, cs_a );
// Make A11 diagonal dominant in order to make sure that
// input matrics are solvable
// Make A11 diagonally dominant in order to make sure that
// input matrices are solvable
for (gtint_t i = 0; i < mn0_a; i++)
{
a[i+i*cs_a] = T{1} / a[i+i*cs_a];