devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Remove random retry loops in tests (batch 2: indices and integer types)"

Browse Source 
This reverts merge request !2261
This commit is contained in:
Rasmus Munk Larsen
2026-03-09 20:01:53 -07:00
parent 54458cb39d
commit 42b6c43cfe
6 changed files with 95 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
test/basicstuff.cpp
View File

@@ -44,15 +44,15 @@ void basicStuff(const MatrixType& m) {
Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
m1.coeffRef(r, c) = x;
VERIFY_IS_EQUAL(x, m1.coeff(r, c));
VERIFY_IS_APPROX(x, m1.coeff(r, c));
m1(r, c) = x;
VERIFY_IS_EQUAL(x, m1(r, c));
VERIFY_IS_APPROX(x, m1(r, c));
v1.coeffRef(r) = x;
VERIFY_IS_EQUAL(x, v1.coeff(r));
VERIFY_IS_APPROX(x, v1.coeff(r));
v1(r) = x;
VERIFY_IS_EQUAL(x, v1(r));
VERIFY_IS_APPROX(x, v1(r));
v1[r] = x;
VERIFY_IS_EQUAL(x, v1[r]);
VERIFY_IS_APPROX(x, v1[r]);
// test fetching with various index types.
Index r1 = internal::random<Index>(0, numext::mini(Index(127), rows - 1));
@@ -68,13 +68,13 @@ void basicStuff(const MatrixType& m) {
if (sizeof(Index) >= sizeof(long long int)) x = v1(static_cast<long long int>(r1));
if (sizeof(Index) >= sizeof(unsigned long long int)) x = v1(static_cast<unsigned long long int>(r1));
VERIFY_IS_EQUAL(v1, v1);
VERIFY_IS_APPROX(v1, v1);
VERIFY_IS_NOT_APPROX(v1, 2 * v1);
VERIFY_IS_MUCH_SMALLER_THAN(vzero, v1);
VERIFY_IS_MUCH_SMALLER_THAN(vzero, v1.squaredNorm());
VERIFY_IS_NOT_MUCH_SMALLER_THAN(v1, v1);
VERIFY_IS_APPROX(vzero, v1 - v1);
VERIFY_IS_EQUAL(m1, m1);
VERIFY_IS_APPROX(m1, m1);
VERIFY_IS_NOT_APPROX(m1, 2 * m1);
VERIFY_IS_MUCH_SMALLER_THAN(mzero, m1);
VERIFY_IS_NOT_MUCH_SMALLER_THAN(m1, m1);
@@ -95,7 +95,7 @@ void basicStuff(const MatrixType& m) {
rv = square.row(r);
cv = square.col(r);
VERIFY_IS_EQUAL(rv, cv.transpose());
VERIFY_IS_APPROX(rv, cv.transpose());
if (cols != 1 && rows != 1 && MatrixType::SizeAtCompileTime != Dynamic) {
VERIFY_RAISES_ASSERT(m1 = (m2.block(0, 0, rows - 1, cols - 1)));
@@ -105,13 +105,13 @@ void basicStuff(const MatrixType& m) {
check_index(m1);
}
VERIFY_IS_EQUAL(m3 = m1, m1);
VERIFY_IS_APPROX(m3 = m1, m1);
MatrixType m4;
VERIFY_IS_EQUAL(m4 = m1, m1);
VERIFY_IS_APPROX(m4 = m1, m1);
m3.real() = m1.real();
VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), m1.real());
VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
// check == / != operators
VERIFY(m1 == m1);
@@ -125,38 +125,38 @@ void basicStuff(const MatrixType& m) {
// check automatic transposition
sm2.setZero();
for (Index i = 0; i < rows; ++i) sm2.col(i) = sm1.row(i);
VERIFY_IS_EQUAL(sm2, sm1.transpose());
VERIFY_IS_APPROX(sm2, sm1.transpose());
sm2.setZero();
for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() = sm1.row(i);
VERIFY_IS_EQUAL(sm2, sm1.transpose());
VERIFY_IS_APPROX(sm2, sm1.transpose());
sm2.setZero();
for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() += sm1.row(i);
VERIFY_IS_EQUAL(sm2, sm1.transpose());
VERIFY_IS_APPROX(sm2, sm1.transpose());
sm2.setZero();
for (Index i = 0; i < rows; ++i) sm2.col(i).noalias() -= sm1.row(i);
VERIFY_IS_EQUAL(sm2, -sm1.transpose());
VERIFY_IS_APPROX(sm2, -sm1.transpose());
// check ternary usage
{
bool b = internal::random<int>(0, 10) > 5;
m3 = b ? m1 : m2;
if (b)
VERIFY_IS_EQUAL(m3, m1);
VERIFY_IS_APPROX(m3, m1);
else
VERIFY_IS_EQUAL(m3, m2);
VERIFY_IS_APPROX(m3, m2);
m3 = b ? -m1 : m2;
if (b)
VERIFY_IS_EQUAL(m3, -m1);
VERIFY_IS_APPROX(m3, -m1);
else
VERIFY_IS_EQUAL(m3, m2);
VERIFY_IS_APPROX(m3, m2);
m3 = b ? m1 : -m2;
if (b)
VERIFY_IS_EQUAL(m3, m1);
VERIFY_IS_APPROX(m3, m1);
else
VERIFY_IS_EQUAL(m3, -m2);
VERIFY_IS_APPROX(m3, -m2);
}
}

6
test/determinant.cpp
View File

@@ -27,8 +27,10 @@ void determinant(const MatrixType& m) {
VERIFY_IS_APPROX((m1 * m2).eval().determinant(), m1.determinant() * m2.determinant());
if (size == 1) return;
Index i = internal::random<Index>(0, size - 1);
Index j = internal::random<Index>(0, size - 2);
if (j >= i) ++j;
Index j;
do {
j = internal::random<Index>(0, size - 1);
} while (j == i);
m2 = m1;
m2.row(i).swap(m2.row(j));
VERIFY_IS_APPROX(m2.determinant(), -m1.determinant());

67
test/integer_types.cpp
View File

@@ -26,13 +26,24 @@ void signed_integer_type_tests(const MatrixType& m) {
MatrixType m1(rows, cols), m2 = MatrixType::Random(rows, cols), mzero = MatrixType::Zero(rows, cols);
m1 = MatrixType::Random(rows, cols);
if (m1 == mzero || m1 == m2) m1(0, 0) = m2(0, 0) + Scalar(1);
{
int guard = 0;
do {
m1 = MatrixType::Random(rows, cols);
} while ((m1 == mzero || m1 == m2) && (++guard) < 100);
VERIFY(guard < 100);
}
// check linear structure
Scalar s1 = internal::random<Scalar>();
if (s1 == 0) s1 = Scalar(1);
Scalar s1;
{
int guard = 0;
do {
s1 = internal::random<Scalar>();
} while (s1 == 0 && (++guard) < 100);
VERIFY(guard < 100);
}
VERIFY_IS_EQUAL(-(-m1), m1);
VERIFY_IS_EQUAL(-m2 + m1 + m2, m1);
@@ -60,26 +71,36 @@ void integer_type_tests(const MatrixType& m) {
SquareMatrixType identity = SquareMatrixType::Identity(rows, rows), square = SquareMatrixType::Random(rows, rows);
VectorType v1(rows), v2 = VectorType::Random(rows), vzero = VectorType::Zero(rows);
m1 = MatrixType::Random(rows, cols);
if (m1 == mzero || m1 == m2) m1(0, 0) = m2(0, 0) + Scalar(1);
{
int guard = 0;
do {
m1 = MatrixType::Random(rows, cols);
} while ((m1 == mzero || m1 == m2) && (++guard) < 100);
VERIFY(guard < 100);
}
v1 = VectorType::Random(rows);
if (v1 == vzero || v1 == v2) v1(0) = v2(0) + Scalar(1);
{
int guard = 0;
do {
v1 = VectorType::Random(rows);
} while ((v1 == vzero || v1 == v2) && (++guard) < 100);
VERIFY(guard < 100);
}
VERIFY_IS_EQUAL(v1, v1);
VERIFY_IS_APPROX(v1, v1);
VERIFY_IS_NOT_APPROX(v1, 2 * v1);
VERIFY_IS_EQUAL(vzero, v1 - v1);
VERIFY_IS_EQUAL(m1, m1);
VERIFY_IS_APPROX(vzero, v1 - v1);
VERIFY_IS_APPROX(m1, m1);
VERIFY_IS_NOT_APPROX(m1, 2 * m1);
VERIFY_IS_EQUAL(mzero, m1 - m1);
VERIFY_IS_APPROX(mzero, m1 - m1);
VERIFY_IS_EQUAL(m3 = m1, m1);
VERIFY_IS_APPROX(m3 = m1, m1);
MatrixType m4;
VERIFY_IS_EQUAL(m4 = m1, m1);
VERIFY_IS_APPROX(m4 = m1, m1);
m3.real() = m1.real();
VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
VERIFY_IS_EQUAL(static_cast<const MatrixType&>(m3).real(), m1.real());
VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), static_cast<const MatrixType&>(m1).real());
VERIFY_IS_APPROX(static_cast<const MatrixType&>(m3).real(), m1.real());
// check == / != operators
VERIFY(m1 == m1);
@@ -92,8 +113,10 @@ void integer_type_tests(const MatrixType& m) {
// check linear structure
Scalar s1 = internal::random<Scalar>();
if (s1 == 0) s1 = Scalar(1);
Scalar s1;
do {
s1 = internal::random<Scalar>();
} while (s1 == 0);
VERIFY_IS_EQUAL(m1 + m1, 2 * m1);
VERIFY_IS_EQUAL(m1 + m2 - m1, m2);
@@ -111,10 +134,10 @@ void integer_type_tests(const MatrixType& m) {
// check matrix product.
VERIFY_IS_EQUAL(identity * m1, m1);
VERIFY_IS_EQUAL(square * (m1 + m2), square * m1 + square * m2);
VERIFY_IS_EQUAL((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
VERIFY_IS_EQUAL((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
VERIFY_IS_APPROX(identity * m1, m1);
VERIFY_IS_APPROX(square * (m1 + m2), square * m1 + square * m2);
VERIFY_IS_APPROX((m1 + m2).transpose() * square, m1.transpose() * square + m2.transpose() * square);
VERIFY_IS_APPROX((m1 * m2.transpose()) * m1, m1 * (m2.transpose() * m1));
}
template <int>

12
test/jacobi.cpp
View File

@@ -28,8 +28,10 @@ void jacobi(const MatrixType& m = MatrixType()) {
{
Index p = internal::random<Index>(0, rows - 1);
Index q = internal::random<Index>(0, rows - 2);
if (q >= p) ++q;
Index q;
do {
q = internal::random<Index>(0, rows - 1);
} while (q == p);
MatrixType b = a;
b.applyOnTheLeft(p, q, rot);
@@ -39,8 +41,10 @@ void jacobi(const MatrixType& m = MatrixType()) {
{
Index p = internal::random<Index>(0, cols - 1);
Index q = internal::random<Index>(0, cols - 2);
if (q >= p) ++q;
Index q;
do {
q = internal::random<Index>(0, cols - 1);
} while (q == p);
MatrixType b = a;
b.applyOnTheRight(p, q, rot);

26
test/linearstructure.cpp
View File

@@ -35,35 +35,35 @@ void linearStructure(const MatrixType& m) {
Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
VERIFY_IS_EQUAL(-(-m1), m1);
VERIFY_IS_EQUAL(m1 + m1, 2 * m1);
VERIFY_IS_APPROX(-(-m1), m1);
VERIFY_IS_APPROX(m1 + m1, 2 * m1);
VERIFY_IS_APPROX(m1 + m2 - m1, m2);
VERIFY_IS_APPROX(-m2 + m1 + m2, m1);
VERIFY_IS_EQUAL(m1 * s1, s1 * m1);
VERIFY_IS_APPROX(m1 * s1, s1 * m1);
VERIFY_IS_APPROX((m1 + m2) * s1, s1 * m1 + s1 * m2);
VERIFY_IS_APPROX((-m1 + m2) * s1, -s1 * m1 + s1 * m2);
m3 = m2;
m3 += m1;
VERIFY_IS_EQUAL(m3, m1 + m2);
VERIFY_IS_APPROX(m3, m1 + m2);
m3 = m2;
m3 -= m1;
VERIFY_IS_EQUAL(m3, m2 - m1);
VERIFY_IS_APPROX(m3, m2 - m1);
m3 = m2;
m3 *= s1;
VERIFY_IS_EQUAL(m3, s1 * m2);
VERIFY_IS_APPROX(m3, s1 * m2);
if (!NumTraits<Scalar>::IsInteger) {
m3 = m2;
m3 /= s1;
VERIFY_IS_EQUAL(m3, m2 / s1);
VERIFY_IS_APPROX(m3, m2 / s1);
}
// again, test operator() to check const-qualification
VERIFY_IS_EQUAL((-m1)(r, c), -(m1(r, c)));
VERIFY_IS_EQUAL((m1 - m2)(r, c), (m1(r, c)) - (m2(r, c)));
VERIFY_IS_EQUAL((m1 + m2)(r, c), (m1(r, c)) + (m2(r, c)));
VERIFY_IS_EQUAL((s1 * m1)(r, c), s1 * (m1(r, c)));
VERIFY_IS_EQUAL((m1 * s1)(r, c), (m1(r, c)) * s1);
if (!NumTraits<Scalar>::IsInteger) VERIFY_IS_EQUAL((m1 / s1)(r, c), (m1(r, c)) / s1);
VERIFY_IS_APPROX((-m1)(r, c), -(m1(r, c)));
VERIFY_IS_APPROX((m1 - m2)(r, c), (m1(r, c)) - (m2(r, c)));
VERIFY_IS_APPROX((m1 + m2)(r, c), (m1(r, c)) + (m2(r, c)));
VERIFY_IS_APPROX((s1 * m1)(r, c), s1 * (m1(r, c)));
VERIFY_IS_APPROX((m1 * s1)(r, c), (m1(r, c)) * s1);
if (!NumTraits<Scalar>::IsInteger) VERIFY_IS_APPROX((m1 / s1)(r, c), (m1(r, c)) / s1);
// use .block to disable vectorization and compare to the vectorized version
VERIFY_IS_APPROX(m1 + m1.block(0, 0, rows, cols), m1 + m1);

6
test/nullary.cpp
View File

@@ -219,9 +219,9 @@ void testMatrixType(const MatrixType& m) {
A = MatrixType::Constant(rows, cols, s1);
Index i = internal::random<Index>(0, rows - 1);
Index j = internal::random<Index>(0, cols - 1);
VERIFY_IS_EQUAL(MatrixType::Constant(rows, cols, s1)(i, j), s1);
VERIFY_IS_EQUAL(MatrixType::Constant(rows, cols, s1).coeff(i, j), s1);
VERIFY_IS_EQUAL(A(i, j), s1);
VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, s1)(i, j), s1);
VERIFY_IS_APPROX(MatrixType::Constant(rows, cols, s1).coeff(i, j), s1);
VERIFY_IS_APPROX(A(i, j), s1);
}
template <int>