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

Clang-format tests, examples, libraries, benchmarks, etc.

Browse Source
This commit is contained in:
Antonio Sánchez
2023-12-05 21:22:55 +00:00
committed by Rasmus Munk Larsen
parent 3252ecc7a4
commit 46e9cdb7fe
876 changed files with 33453 additions and 37795 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
test/lu.cpp
View File

@@ -12,55 +12,43 @@
#include "solverbase.h"
using namespace std;
template<typename MatrixType>
template <typename MatrixType>
typename MatrixType::RealScalar matrix_l1_norm(const MatrixType& m) {
return m.cwiseAbs().colwise().sum().maxCoeff();
}
template<typename MatrixType> void lu_non_invertible()
{
template <typename MatrixType>
void lu_non_invertible() {
typedef typename MatrixType::RealScalar RealScalar;
/* this test covers the following files:
LU.h
*/
Index rows, cols, cols2;
if(MatrixType::RowsAtCompileTime==Dynamic)
{
rows = internal::random<Index>(2,EIGEN_TEST_MAX_SIZE);
}
else
{
if (MatrixType::RowsAtCompileTime == Dynamic) {
rows = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
} else {
rows = MatrixType::RowsAtCompileTime;
}
if(MatrixType::ColsAtCompileTime==Dynamic)
{
cols = internal::random<Index>(2,EIGEN_TEST_MAX_SIZE);
cols2 = internal::random<int>(2,EIGEN_TEST_MAX_SIZE);
}
else
{
if (MatrixType::ColsAtCompileTime == Dynamic) {
cols = internal::random<Index>(2, EIGEN_TEST_MAX_SIZE);
cols2 = internal::random<int>(2, EIGEN_TEST_MAX_SIZE);
} else {
cols2 = cols = MatrixType::ColsAtCompileTime;
}
enum {
RowsAtCompileTime = MatrixType::RowsAtCompileTime,
ColsAtCompileTime = MatrixType::ColsAtCompileTime
};
enum { RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime };
typedef typename internal::kernel_retval_base<FullPivLU<MatrixType> >::ReturnType KernelMatrixType;
typedef typename internal::image_retval_base<FullPivLU<MatrixType> >::ReturnType ImageMatrixType;
typedef Matrix<typename MatrixType::Scalar, ColsAtCompileTime, ColsAtCompileTime>
CMatrixType;
typedef Matrix<typename MatrixType::Scalar, RowsAtCompileTime, RowsAtCompileTime>
RMatrixType;
typedef Matrix<typename MatrixType::Scalar, ColsAtCompileTime, ColsAtCompileTime> CMatrixType;
typedef Matrix<typename MatrixType::Scalar, RowsAtCompileTime, RowsAtCompileTime> RMatrixType;
Index rank = internal::random<Index>(1, (std::min)(rows, cols)-1);
Index rank = internal::random<Index>(1, (std::min)(rows, cols) - 1);
// The image of the zero matrix should consist of a single (zero) column vector
VERIFY((MatrixType::Zero(rows,cols).fullPivLu().image(MatrixType::Zero(rows,cols)).cols() == 1));
VERIFY((MatrixType::Zero(rows, cols).fullPivLu().image(MatrixType::Zero(rows, cols)).cols() == 1));
// The kernel of the zero matrix is the entire space, and thus is an invertible matrix of dimensions cols.
KernelMatrixType kernel = MatrixType::Zero(rows,cols).fullPivLu().kernel();
KernelMatrixType kernel = MatrixType::Zero(rows, cols).fullPivLu().kernel();
VERIFY((kernel.fullPivLu().isInvertible()));
MatrixType m1(rows, cols), m3(rows, cols2);
@@ -75,13 +63,13 @@ template<typename MatrixType> void lu_non_invertible()
lu.setThreshold(RealScalar(0.01));
lu.compute(m1);
MatrixType u(rows,cols);
MatrixType u(rows, cols);
u = lu.matrixLU().template triangularView<Upper>();
RMatrixType l = RMatrixType::Identity(rows,rows);
l.block(0,0,rows,(std::min)(rows,cols)).template triangularView<StrictlyLower>()
= lu.matrixLU().block(0,0,rows,(std::min)(rows,cols));
RMatrixType l = RMatrixType::Identity(rows, rows);
l.block(0, 0, rows, (std::min)(rows, cols)).template triangularView<StrictlyLower>() =
lu.matrixLU().block(0, 0, rows, (std::min)(rows, cols));
VERIFY_IS_APPROX(lu.permutationP() * m1 * lu.permutationQ(), l*u);
VERIFY_IS_APPROX(lu.permutationP() * m1 * lu.permutationQ(), l * u);
KernelMatrixType m1kernel = lu.kernel();
ImageMatrixType m1image = lu.image(m1);
@@ -98,35 +86,34 @@ template<typename MatrixType> void lu_non_invertible()
check_solverbase<CMatrixType, MatrixType>(m1, lu, rows, cols, cols2);
m2 = CMatrixType::Random(cols,cols2);
m3 = m1*m2;
m2 = CMatrixType::Random(cols,cols2);
m2 = CMatrixType::Random(cols, cols2);
m3 = m1 * m2;
m2 = CMatrixType::Random(cols, cols2);
// test that the code, which does resize(), may be applied to an xpr
m2.block(0,0,m2.rows(),m2.cols()) = lu.solve(m3);
VERIFY_IS_APPROX(m3, m1*m2);
m2.block(0, 0, m2.rows(), m2.cols()) = lu.solve(m3);
VERIFY_IS_APPROX(m3, m1 * m2);
}
template<typename MatrixType> void lu_invertible()
{
template <typename MatrixType>
void lu_invertible() {
/* this test covers the following files:
FullPivLU.h
*/
typedef typename NumTraits<typename MatrixType::Scalar>::Real RealScalar;
Index size = MatrixType::RowsAtCompileTime;
if( size==Dynamic)
size = internal::random<Index>(1,EIGEN_TEST_MAX_SIZE);
if (size == Dynamic) size = internal::random<Index>(1, EIGEN_TEST_MAX_SIZE);
MatrixType m1(size, size), m2(size, size), m3(size, size);
FullPivLU<MatrixType> lu;
lu.setThreshold(RealScalar(0.01));
do {
m1 = MatrixType::Random(size,size);
m1 = MatrixType::Random(size, size);
lu.compute(m1);
} while(!lu.isInvertible());
} while (!lu.isInvertible());
VERIFY_IS_APPROX(m1, lu.reconstructedMatrix());
VERIFY(0 == lu.dimensionOfKernel());
VERIFY(lu.kernel().cols() == 1); // the kernel() should consist of a single (zero) column vector
VERIFY(lu.kernel().cols() == 1); // the kernel() should consist of a single (zero) column vector
VERIFY(size == lu.rank());
VERIFY(lu.isInjective());
VERIFY(lu.isSurjective());
@@ -136,9 +123,9 @@ template<typename MatrixType> void lu_invertible()
check_solverbase<MatrixType, MatrixType>(m1, lu, size, size, size);
MatrixType m1_inverse = lu.inverse();
m3 = MatrixType::Random(size,size);
m3 = MatrixType::Random(size, size);
m2 = lu.solve(m3);
VERIFY_IS_APPROX(m2, m1_inverse*m3);
VERIFY_IS_APPROX(m2, m1_inverse * m3);
RealScalar rcond = (RealScalar(1) / matrix_l1_norm(m1)) / matrix_l1_norm(m1_inverse);
const RealScalar rcond_est = lu.rcond();
@@ -147,12 +134,12 @@ template<typename MatrixType> void lu_invertible()
VERIFY(rcond_est > rcond / 10 && rcond_est < rcond * 10);
// Regression test for Bug 302
MatrixType m4 = MatrixType::Random(size,size);
VERIFY_IS_APPROX(lu.solve(m3*m4), lu.solve(m3)*m4);
MatrixType m4 = MatrixType::Random(size, size);
VERIFY_IS_APPROX(lu.solve(m3 * m4), lu.solve(m3) * m4);
}
template<typename MatrixType> void lu_partial_piv(Index size = MatrixType::ColsAtCompileTime)
{
template <typename MatrixType>
void lu_partial_piv(Index size = MatrixType::ColsAtCompileTime) {
/* this test covers the following files:
PartialPivLU.h
*/
@@ -167,9 +154,9 @@ template<typename MatrixType> void lu_partial_piv(Index size = MatrixType::ColsA
check_solverbase<MatrixType, MatrixType>(m1, plu, size, size, size);
MatrixType m1_inverse = plu.inverse();
m3 = MatrixType::Random(size,size);
m3 = MatrixType::Random(size, size);
m2 = plu.solve(m3);
VERIFY_IS_APPROX(m2, m1_inverse*m3);
VERIFY_IS_APPROX(m2, m1_inverse * m3);
RealScalar rcond = (RealScalar(1) / matrix_l1_norm(m1)) / matrix_l1_norm(m1_inverse);
const RealScalar rcond_est = plu.rcond();
@@ -177,8 +164,8 @@ template<typename MatrixType> void lu_partial_piv(Index size = MatrixType::ColsA
VERIFY(rcond_est > rcond / 10 && rcond_est < rcond * 10);
}
template<typename MatrixType> void lu_verify_assert()
{
template <typename MatrixType>
void lu_verify_assert() {
MatrixType tmp;
FullPivLU<MatrixType> lu;
@@ -208,42 +195,41 @@ template<typename MatrixType> void lu_verify_assert()
VERIFY_RAISES_ASSERT(plu.inverse())
}
EIGEN_DECLARE_TEST(lu)
{
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( lu_non_invertible<Matrix3f>() );
CALL_SUBTEST_1( lu_invertible<Matrix3f>() );
CALL_SUBTEST_1( lu_verify_assert<Matrix3f>() );
CALL_SUBTEST_1( lu_partial_piv<Matrix3f>() );
EIGEN_DECLARE_TEST(lu) {
for (int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1(lu_non_invertible<Matrix3f>());
CALL_SUBTEST_1(lu_invertible<Matrix3f>());
CALL_SUBTEST_1(lu_verify_assert<Matrix3f>());
CALL_SUBTEST_1(lu_partial_piv<Matrix3f>());
CALL_SUBTEST_2( (lu_non_invertible<Matrix<double, 4, 6> >()) );
CALL_SUBTEST_2( (lu_verify_assert<Matrix<double, 4, 6> >()) );
CALL_SUBTEST_2( lu_partial_piv<Matrix2d>() );
CALL_SUBTEST_2( lu_partial_piv<Matrix4d>() );
CALL_SUBTEST_2( (lu_partial_piv<Matrix<double,6,6> >()) );
CALL_SUBTEST_2((lu_non_invertible<Matrix<double, 4, 6> >()));
CALL_SUBTEST_2((lu_verify_assert<Matrix<double, 4, 6> >()));
CALL_SUBTEST_2(lu_partial_piv<Matrix2d>());
CALL_SUBTEST_2(lu_partial_piv<Matrix4d>());
CALL_SUBTEST_2((lu_partial_piv<Matrix<double, 6, 6> >()));
CALL_SUBTEST_3( lu_non_invertible<MatrixXf>() );
CALL_SUBTEST_3( lu_invertible<MatrixXf>() );
CALL_SUBTEST_3( lu_verify_assert<MatrixXf>() );
CALL_SUBTEST_3(lu_non_invertible<MatrixXf>());
CALL_SUBTEST_3(lu_invertible<MatrixXf>());
CALL_SUBTEST_3(lu_verify_assert<MatrixXf>());
CALL_SUBTEST_4( lu_non_invertible<MatrixXd>() );
CALL_SUBTEST_4( lu_invertible<MatrixXd>() );
CALL_SUBTEST_4( lu_partial_piv<MatrixXd>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE)) );
CALL_SUBTEST_4( lu_verify_assert<MatrixXd>() );
CALL_SUBTEST_4(lu_non_invertible<MatrixXd>());
CALL_SUBTEST_4(lu_invertible<MatrixXd>());
CALL_SUBTEST_4(lu_partial_piv<MatrixXd>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
CALL_SUBTEST_4(lu_verify_assert<MatrixXd>());
CALL_SUBTEST_5( lu_non_invertible<MatrixXcf>() );
CALL_SUBTEST_5( lu_invertible<MatrixXcf>() );
CALL_SUBTEST_5( lu_verify_assert<MatrixXcf>() );
CALL_SUBTEST_5(lu_non_invertible<MatrixXcf>());
CALL_SUBTEST_5(lu_invertible<MatrixXcf>());
CALL_SUBTEST_5(lu_verify_assert<MatrixXcf>());
CALL_SUBTEST_6( lu_non_invertible<MatrixXcd>() );
CALL_SUBTEST_6( lu_invertible<MatrixXcd>() );
CALL_SUBTEST_6( lu_partial_piv<MatrixXcd>(internal::random<int>(1,EIGEN_TEST_MAX_SIZE)) );
CALL_SUBTEST_6( lu_verify_assert<MatrixXcd>() );
CALL_SUBTEST_6(lu_non_invertible<MatrixXcd>());
CALL_SUBTEST_6(lu_invertible<MatrixXcd>());
CALL_SUBTEST_6(lu_partial_piv<MatrixXcd>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE)));
CALL_SUBTEST_6(lu_verify_assert<MatrixXcd>());
CALL_SUBTEST_7(( lu_non_invertible<Matrix<float,Dynamic,16> >() ));
CALL_SUBTEST_7((lu_non_invertible<Matrix<float, Dynamic, 16> >()));
// Test problem size constructors
CALL_SUBTEST_9( PartialPivLU<MatrixXf>(10) );
CALL_SUBTEST_9( FullPivLU<MatrixXf>(10, 20); );
CALL_SUBTEST_9(PartialPivLU<MatrixXf>(10));
CALL_SUBTEST_9(FullPivLU<MatrixXf>(10, 20););
}
}