151 lines
6.0 KiB
C++
151 lines
6.0 KiB
C++
// This file is part of Eigen, a lightweight C++ template library
|
|
// for linear algebra.
|
|
//
|
|
// Copyright (C) 2006-2008 Benoit Jacob <jacob.benoit.1@gmail.com>
|
|
//
|
|
// This Source Code Form is subject to the terms of the Mozilla
|
|
// Public License v. 2.0. If a copy of the MPL was not distributed
|
|
// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
#include "product.h"
|
|
#include <Eigen/LU>
|
|
|
|
template <typename T>
|
|
void test_aliasing() {
|
|
int rows = internal::random<int>(1, 12);
|
|
int cols = internal::random<int>(1, 12);
|
|
typedef Matrix<T, Dynamic, Dynamic> MatrixType;
|
|
typedef Matrix<T, Dynamic, 1> VectorType;
|
|
VectorType x(cols);
|
|
x.setRandom();
|
|
VectorType z(x);
|
|
VectorType y(rows);
|
|
y.setZero();
|
|
MatrixType A(rows, cols);
|
|
A.setRandom();
|
|
// CwiseBinaryOp
|
|
VERIFY_IS_APPROX(x = y + A * x, A * z); // OK because "y + A*x" is marked as "assume-aliasing"
|
|
x = z;
|
|
// CwiseUnaryOp
|
|
VERIFY_IS_APPROX(x = T(1.) * (A * x),
|
|
A * z); // OK because 1*(A*x) is replaced by (1*A*x) which is a Product<> expression
|
|
x = z;
|
|
// VERIFY_IS_APPROX(x = y-A*x, -A*z); // Not OK in 3.3 because x is resized before A*x gets evaluated
|
|
x = z;
|
|
}
|
|
|
|
template <int>
|
|
void product_large_regressions() {
|
|
{
|
|
// test a specific issue in DiagonalProduct
|
|
int N = 1000000;
|
|
VectorXf v = VectorXf::Ones(N);
|
|
MatrixXf m = MatrixXf::Ones(N, 3);
|
|
m = (v + v).asDiagonal() * m;
|
|
VERIFY_IS_APPROX(m, MatrixXf::Constant(N, 3, 2));
|
|
}
|
|
|
|
{
|
|
// test deferred resizing in Matrix::operator=
|
|
MatrixXf a = MatrixXf::Random(10, 4), b = MatrixXf::Random(4, 10), c = a;
|
|
VERIFY_IS_APPROX((a = a * b), (c * b).eval());
|
|
}
|
|
|
|
{
|
|
// check the functions to setup blocking sizes compile and do not segfault
|
|
// FIXME check they do what they are supposed to do !!
|
|
std::ptrdiff_t l1 = internal::random<int>(10000, 20000);
|
|
std::ptrdiff_t l2 = internal::random<int>(100000, 200000);
|
|
std::ptrdiff_t l3 = internal::random<int>(1000000, 2000000);
|
|
setCpuCacheSizes(l1, l2, l3);
|
|
VERIFY(l1 == l1CacheSize());
|
|
VERIFY(l2 == l2CacheSize());
|
|
std::ptrdiff_t k1 = internal::random<int>(10, 100) * 16;
|
|
std::ptrdiff_t m1 = internal::random<int>(10, 100) * 16;
|
|
std::ptrdiff_t n1 = internal::random<int>(10, 100) * 16;
|
|
// only makes sure it compiles fine
|
|
internal::computeProductBlockingSizes<float, float, std::ptrdiff_t>(k1, m1, n1, 1);
|
|
}
|
|
|
|
{
|
|
// test regression in row-vector by matrix (bad Map type)
|
|
MatrixXf mat1(10, 32);
|
|
mat1.setRandom();
|
|
MatrixXf mat2(32, 32);
|
|
mat2.setRandom();
|
|
MatrixXf r1 = mat1.row(2) * mat2.transpose();
|
|
VERIFY_IS_APPROX(r1, (mat1.row(2) * mat2.transpose()).eval());
|
|
|
|
MatrixXf r2 = mat1.row(2) * mat2;
|
|
VERIFY_IS_APPROX(r2, (mat1.row(2) * mat2).eval());
|
|
}
|
|
|
|
{
|
|
Eigen::MatrixXd A(10, 10), B, C;
|
|
A.setRandom();
|
|
C = A;
|
|
for (int k = 0; k < 79; ++k) C = C * A;
|
|
B.noalias() =
|
|
(((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) *
|
|
((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A))) *
|
|
(((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) *
|
|
((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)) * ((A * A) * (A * A)));
|
|
VERIFY_IS_APPROX(B, C);
|
|
}
|
|
}
|
|
|
|
template <int>
|
|
void bug_1622() {
|
|
typedef Matrix<double, 2, -1, 0, 2, -1> Mat2X;
|
|
Mat2X x(2, 2);
|
|
x.setRandom();
|
|
MatrixXd y(2, 2);
|
|
y.setRandom();
|
|
const Mat2X K1 = x * y.inverse();
|
|
const Matrix2d K2 = x * y.inverse();
|
|
VERIFY_IS_APPROX(K1, K2);
|
|
}
|
|
|
|
EIGEN_DECLARE_TEST(product_large) {
|
|
for (int i = 0; i < g_repeat; i++) {
|
|
CALL_SUBTEST_1(product(
|
|
MatrixXf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
CALL_SUBTEST_2(product(
|
|
MatrixXd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
CALL_SUBTEST_2(product(MatrixXd(internal::random<int>(1, 10), internal::random<int>(1, 10))));
|
|
|
|
CALL_SUBTEST_3(product(
|
|
MatrixXi(internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
CALL_SUBTEST_4(product(MatrixXcf(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2),
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));
|
|
CALL_SUBTEST_5(product(Matrix<float, Dynamic, Dynamic, RowMajor>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
|
|
CALL_SUBTEST_1(test_aliasing<float>());
|
|
|
|
CALL_SUBTEST_6(bug_1622<1>());
|
|
|
|
CALL_SUBTEST_7(product(MatrixXcd(internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2),
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE / 2))));
|
|
CALL_SUBTEST_8(product(Matrix<double, Dynamic, Dynamic, RowMajor>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
CALL_SUBTEST_9(product(Matrix<std::complex<float>, Dynamic, Dynamic, RowMajor>(
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
CALL_SUBTEST_10(product(Matrix<std::complex<double>, Dynamic, Dynamic, RowMajor>(
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
CALL_SUBTEST_11(product(Matrix<bfloat16, Dynamic, Dynamic, RowMajor>(
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE), internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
}
|
|
|
|
CALL_SUBTEST_6(product_large_regressions<0>());
|
|
|
|
// Regression test for bug 714:
|
|
#if defined EIGEN_HAS_OPENMP
|
|
omp_set_dynamic(1);
|
|
for (int i = 0; i < g_repeat; i++) {
|
|
CALL_SUBTEST_6(product(Matrix<float, Dynamic, Dynamic>(internal::random<int>(1, EIGEN_TEST_MAX_SIZE),
|
|
internal::random<int>(1, EIGEN_TEST_MAX_SIZE))));
|
|
}
|
|
#endif
|
|
}
|