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

199
test/adjoint.cpp
View File

@@ -9,30 +9,35 @@
#include "main.h"
template<bool IsInteger> struct adjoint_specific;
template <bool IsInteger>
struct adjoint_specific;
template<> struct adjoint_specific<true> {
template<typename Vec, typename Mat, typename Scalar>
template <>
struct adjoint_specific<true> {
template <typename Vec, typename Mat, typename Scalar>
static void run(const Vec& v1, const Vec& v2, Vec& v3, const Mat& square, Scalar s1, Scalar s2) {
VERIFY(test_isApproxWithRef((s1 * v1 + s2 * v2).dot(v3), numext::conj(s1) * v1.dot(v3) + numext::conj(s2) * v2.dot(v3), 0));
VERIFY(test_isApproxWithRef(v3.dot(s1 * v1 + s2 * v2), s1*v3.dot(v1)+s2*v3.dot(v2), 0));
VERIFY(test_isApproxWithRef((s1 * v1 + s2 * v2).dot(v3),
numext::conj(s1) * v1.dot(v3) + numext::conj(s2) * v2.dot(v3), 0));
VERIFY(test_isApproxWithRef(v3.dot(s1 * v1 + s2 * v2), s1 * v3.dot(v1) + s2 * v3.dot(v2), 0));
// check compatibility of dot and adjoint
VERIFY(test_isApproxWithRef(v1.dot(square * v2), (square.adjoint() * v1).dot(v2), 0));
}
};
template<> struct adjoint_specific<false> {
template<typename Vec, typename Mat, typename Scalar>
template <>
struct adjoint_specific<false> {
template <typename Vec, typename Mat, typename Scalar>
static void run(const Vec& v1, const Vec& v2, Vec& v3, const Mat& square, Scalar s1, Scalar s2) {
typedef typename NumTraits<Scalar>::Real RealScalar;
using std::abs;
RealScalar ref = NumTraits<Scalar>::IsInteger ? RealScalar(0) : (std::max)((s1 * v1 + s2 * v2).norm(),v3.norm());
VERIFY(test_isApproxWithRef((s1 * v1 + s2 * v2).dot(v3), numext::conj(s1) * v1.dot(v3) + numext::conj(s2) * v2.dot(v3), ref));
VERIFY(test_isApproxWithRef(v3.dot(s1 * v1 + s2 * v2), s1*v3.dot(v1)+s2*v3.dot(v2), ref));
VERIFY_IS_APPROX(v1.squaredNorm(), v1.norm() * v1.norm());
RealScalar ref = NumTraits<Scalar>::IsInteger ? RealScalar(0) : (std::max)((s1 * v1 + s2 * v2).norm(), v3.norm());
VERIFY(test_isApproxWithRef((s1 * v1 + s2 * v2).dot(v3),
numext::conj(s1) * v1.dot(v3) + numext::conj(s2) * v2.dot(v3), ref));
VERIFY(test_isApproxWithRef(v3.dot(s1 * v1 + s2 * v2), s1 * v3.dot(v1) + s2 * v3.dot(v2), ref));
VERIFY_IS_APPROX(v1.squaredNorm(), v1.norm() * v1.norm());
// check normalized() and normalize()
VERIFY_IS_APPROX(v1, v1.norm() * v1.normalized());
v3 = v1;
@@ -42,39 +47,42 @@ template<> struct adjoint_specific<false> {
VERIFY_IS_APPROX(v3.norm(), RealScalar(1));
// check null inputs
VERIFY_IS_APPROX((v1*0).normalized(), (v1*0));
VERIFY_IS_APPROX((v1 * 0).normalized(), (v1 * 0));
#if (!EIGEN_ARCH_i386) || defined(EIGEN_VECTORIZE)
RealScalar very_small = (std::numeric_limits<RealScalar>::min)();
VERIFY( numext::is_exactly_zero((v1*very_small).norm()) );
VERIFY_IS_APPROX((v1*very_small).normalized(), (v1*very_small));
v3 = v1*very_small;
VERIFY(numext::is_exactly_zero((v1 * very_small).norm()));
VERIFY_IS_APPROX((v1 * very_small).normalized(), (v1 * very_small));
v3 = v1 * very_small;
v3.normalize();
VERIFY_IS_APPROX(v3, (v1*very_small));
VERIFY_IS_APPROX(v3, (v1 * very_small));
#endif
// check compatibility of dot and adjoint
ref = NumTraits<Scalar>::IsInteger ? 0 : (std::max)((std::max)(v1.norm(),v2.norm()),(std::max)((square * v2).norm(),(square.adjoint() * v1).norm()));
VERIFY(internal::isMuchSmallerThan(abs(v1.dot(square * v2) - (square.adjoint() * v1).dot(v2)), ref, test_precision<Scalar>()));
ref = NumTraits<Scalar>::IsInteger ? 0
: (std::max)((std::max)(v1.norm(), v2.norm()),
(std::max)((square * v2).norm(), (square.adjoint() * v1).norm()));
VERIFY(internal::isMuchSmallerThan(abs(v1.dot(square * v2) - (square.adjoint() * v1).dot(v2)), ref,
test_precision<Scalar>()));
// check that Random().normalized() works: tricky as the random xpr must be evaluated by
// normalized() in order to produce a consistent result.
VERIFY_IS_APPROX(Vec::Random(v1.size()).normalized().norm(), RealScalar(1));
}
};
template<typename MatrixType, typename Scalar = typename MatrixType::Scalar>
template <typename MatrixType, typename Scalar = typename MatrixType::Scalar>
MatrixType RandomMatrix(Index rows, Index cols, Scalar min, Scalar max) {
MatrixType M = MatrixType(rows, cols);
for (Index i=0; i<rows; ++i) {
for (Index j=0; j<cols; ++j) {
for (Index i = 0; i < rows; ++i) {
for (Index j = 0; j < cols; ++j) {
M(i, j) = Eigen::internal::random<Scalar>(min, max);
}
}
return M;
}
template<typename MatrixType> void adjoint(const MatrixType& m)
{
template <typename MatrixType>
void adjoint(const MatrixType& m) {
/* this test covers the following files:
Transpose.h Conjugate.h Dot.h
*/
@@ -84,7 +92,7 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> SquareMatrixType;
const Index PacketSize = internal::packet_traits<Scalar>::size;
Index rows = m.rows();
Index cols = m.cols();
@@ -93,79 +101,73 @@ template<typename MatrixType> void adjoint(const MatrixType& m)
RealScalar rmax = static_cast<RealScalar>(NumTraits<Scalar>::IsInteger ? 100 : 1);
MatrixType m1 = RandomMatrix<MatrixType>(rows, cols, rmin, rmax),
m2 = RandomMatrix<MatrixType>(rows, cols, rmin, rmax),
m3(rows, cols),
m2 = RandomMatrix<MatrixType>(rows, cols, rmin, rmax), m3(rows, cols),
square = RandomMatrix<SquareMatrixType>(rows, rows, rmin, rmax);
VectorType v1 = RandomMatrix<VectorType>(rows, 1, rmin, rmax),
v2 = RandomMatrix<VectorType>(rows, 1, rmin, rmax),
v3 = RandomMatrix<VectorType>(rows, 1, rmin, rmax),
vzero = VectorType::Zero(rows);
VectorType v1 = RandomMatrix<VectorType>(rows, 1, rmin, rmax), v2 = RandomMatrix<VectorType>(rows, 1, rmin, rmax),
v3 = RandomMatrix<VectorType>(rows, 1, rmin, rmax), vzero = VectorType::Zero(rows);
Scalar s1 = internal::random<Scalar>(rmin, rmax),
s2 = internal::random<Scalar>(rmin, rmax);
Scalar s1 = internal::random<Scalar>(rmin, rmax), s2 = internal::random<Scalar>(rmin, rmax);
// check basic compatibility of adjoint, transpose, conjugate
VERIFY_IS_APPROX(m1.transpose().conjugate().adjoint(), m1);
VERIFY_IS_APPROX(m1.adjoint().conjugate().transpose(), m1);
VERIFY_IS_APPROX(m1.transpose().conjugate().adjoint(), m1);
VERIFY_IS_APPROX(m1.adjoint().conjugate().transpose(), m1);
// check multiplicative behavior
VERIFY_IS_APPROX((m1.adjoint() * m2).adjoint(), m2.adjoint() * m1);
VERIFY_IS_APPROX((s1 * m1).adjoint(), numext::conj(s1) * m1.adjoint());
VERIFY_IS_APPROX((m1.adjoint() * m2).adjoint(), m2.adjoint() * m1);
VERIFY_IS_APPROX((s1 * m1).adjoint(), numext::conj(s1) * m1.adjoint());
// check basic properties of dot, squaredNorm
VERIFY_IS_APPROX(numext::conj(v1.dot(v2)), v2.dot(v1));
VERIFY_IS_APPROX(numext::real(v1.dot(v1)), v1.squaredNorm());
VERIFY_IS_APPROX(numext::conj(v1.dot(v2)), v2.dot(v1));
VERIFY_IS_APPROX(numext::real(v1.dot(v1)), v1.squaredNorm());
adjoint_specific<NumTraits<Scalar>::IsInteger>::run(v1, v2, v3, square, s1, s2);
VERIFY_IS_MUCH_SMALLER_THAN(abs(vzero.dot(v1)), static_cast<RealScalar>(1));
VERIFY_IS_MUCH_SMALLER_THAN(abs(vzero.dot(v1)), static_cast<RealScalar>(1));
// like in testBasicStuff, test operator() to check const-qualification
Index r = internal::random<Index>(0, rows-1),
c = internal::random<Index>(0, cols-1);
VERIFY_IS_APPROX(m1.conjugate()(r,c), numext::conj(m1(r,c)));
VERIFY_IS_APPROX(m1.adjoint()(c,r), numext::conj(m1(r,c)));
Index r = internal::random<Index>(0, rows - 1), c = internal::random<Index>(0, cols - 1);
VERIFY_IS_APPROX(m1.conjugate()(r, c), numext::conj(m1(r, c)));
VERIFY_IS_APPROX(m1.adjoint()(c, r), numext::conj(m1(r, c)));
// check inplace transpose
m3 = m1;
m3.transposeInPlace();
VERIFY_IS_APPROX(m3,m1.transpose());
VERIFY_IS_APPROX(m3, m1.transpose());
m3.transposeInPlace();
VERIFY_IS_APPROX(m3,m1);
if(PacketSize<m3.rows() && PacketSize<m3.cols())
{
VERIFY_IS_APPROX(m3, m1);
if (PacketSize < m3.rows() && PacketSize < m3.cols()) {
m3 = m1;
Index i = internal::random<Index>(0,m3.rows()-PacketSize);
Index j = internal::random<Index>(0,m3.cols()-PacketSize);
m3.template block<PacketSize,PacketSize>(i,j).transposeInPlace();
VERIFY_IS_APPROX( (m3.template block<PacketSize,PacketSize>(i,j)), (m1.template block<PacketSize,PacketSize>(i,j).transpose()) );
m3.template block<PacketSize,PacketSize>(i,j).transposeInPlace();
VERIFY_IS_APPROX(m3,m1);
Index i = internal::random<Index>(0, m3.rows() - PacketSize);
Index j = internal::random<Index>(0, m3.cols() - PacketSize);
m3.template block<PacketSize, PacketSize>(i, j).transposeInPlace();
VERIFY_IS_APPROX((m3.template block<PacketSize, PacketSize>(i, j)),
(m1.template block<PacketSize, PacketSize>(i, j).transpose()));
m3.template block<PacketSize, PacketSize>(i, j).transposeInPlace();
VERIFY_IS_APPROX(m3, m1);
}
// check inplace adjoint
m3 = m1;
m3.adjointInPlace();
VERIFY_IS_APPROX(m3,m1.adjoint());
VERIFY_IS_APPROX(m3, m1.adjoint());
m3.transposeInPlace();
VERIFY_IS_APPROX(m3,m1.conjugate());
VERIFY_IS_APPROX(m3, m1.conjugate());
// check mixed dot product
typedef Matrix<RealScalar, MatrixType::RowsAtCompileTime, 1> RealVectorType;
RealVectorType rv1 = RandomMatrix<RealVectorType>(rows, 1, rmin, rmax);
VERIFY_IS_APPROX(v1.dot(rv1.template cast<Scalar>()), v1.dot(rv1));
VERIFY_IS_APPROX(rv1.template cast<Scalar>().dot(v1), rv1.dot(v1));
VERIFY( is_same_type(m1,m1.template conjugateIf<false>()) );
VERIFY( is_same_type(m1.conjugate(),m1.template conjugateIf<true>()) );
VERIFY(is_same_type(m1, m1.template conjugateIf<false>()));
VERIFY(is_same_type(m1.conjugate(), m1.template conjugateIf<true>()));
}
template<int>
void adjoint_extra()
{
MatrixXcf a(10,10), b(10,10);
template <int>
void adjoint_extra() {
MatrixXcf a(10, 10), b(10, 10);
VERIFY_RAISES_ASSERT(a = a.transpose());
VERIFY_RAISES_ASSERT(a = a.transpose() + b);
VERIFY_RAISES_ASSERT(a = b + a.transpose());
@@ -183,11 +185,11 @@ void adjoint_extra()
a.transpose() += a.adjoint() + b;
// regression tests for check_for_aliasing
MatrixXd c(10,10);
c = 1.0 * MatrixXd::Ones(10,10) + c;
c = MatrixXd::Ones(10,10) * 1.0 + c;
c = c + MatrixXd::Ones(10,10) .cwiseProduct( MatrixXd::Zero(10,10) );
c = MatrixXd::Ones(10,10) * MatrixXd::Zero(10,10);
MatrixXd c(10, 10);
c = 1.0 * MatrixXd::Ones(10, 10) + c;
c = MatrixXd::Ones(10, 10) * 1.0 + c;
c = c + MatrixXd::Ones(10, 10).cwiseProduct(MatrixXd::Zero(10, 10));
c = MatrixXd::Ones(10, 10) * MatrixXd::Zero(10, 10);
// regression for bug 1646
for (int j = 0; j < 10; ++j) {
@@ -198,36 +200,37 @@ void adjoint_extra()
c.col(j) = c.row(j);
}
a.conservativeResize(1,1);
a.conservativeResize(1, 1);
a = a.transpose();
a.conservativeResize(0,0);
a.conservativeResize(0, 0);
a = a.transpose();
}
EIGEN_DECLARE_TEST(adjoint)
{
for(int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1( adjoint(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( adjoint(Matrix3d()) );
CALL_SUBTEST_3( adjoint(Matrix4f()) );
CALL_SUBTEST_4( adjoint(MatrixXcf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2), internal::random<int>(1,EIGEN_TEST_MAX_SIZE/2))) );
CALL_SUBTEST_5( adjoint(MatrixXi(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
CALL_SUBTEST_6( adjoint(MatrixXf(internal::random<int>(1,EIGEN_TEST_MAX_SIZE), internal::random<int>(1,EIGEN_TEST_MAX_SIZE))) );
EIGEN_DECLARE_TEST(adjoint) {
for (int i = 0; i < g_repeat; i++) {
CALL_SUBTEST_1(adjoint(Matrix<float, 1, 1>()));
CALL_SUBTEST_2(adjoint(Matrix3d()));
CALL_SUBTEST_3(adjoint(Matrix4f()));
CALL_SUBTEST_4(adjoint(MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2),
internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));
CALL_SUBTEST_5(adjoint(
MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
CALL_SUBTEST_6(adjoint(
MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
// Complement for 128 bits vectorization:
CALL_SUBTEST_8( adjoint(Matrix2d()) );
CALL_SUBTEST_9( adjoint(Matrix<int,4,4>()) );
CALL_SUBTEST_8(adjoint(Matrix2d()));
CALL_SUBTEST_9(adjoint(Matrix<int, 4, 4>()));
// 256 bits vectorization:
CALL_SUBTEST_10( adjoint(Matrix<float,8,8>()) );
CALL_SUBTEST_11( adjoint(Matrix<double,4,4>()) );
CALL_SUBTEST_12( adjoint(Matrix<int,8,8>()) );
CALL_SUBTEST_10(adjoint(Matrix<float, 8, 8>()));
CALL_SUBTEST_11(adjoint(Matrix<double, 4, 4>()));
CALL_SUBTEST_12(adjoint(Matrix<int, 8, 8>()));
}
// test a large static matrix only once
CALL_SUBTEST_7( adjoint(Matrix<float, 100, 100>()) );
CALL_SUBTEST_7(adjoint(Matrix<float, 100, 100>()));
CALL_SUBTEST_13( adjoint_extra<0>() );
CALL_SUBTEST_13(adjoint_extra<0>());
}