Macros | Functions
redux.cpp File Reference
#include "main.h"

Macros

#define TEST_ENABLE_TEMPORARY_TRACKING
 
#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD   8
 

Functions

template<typename MatrixType >
void matrixRedux (const MatrixType &m)
 
template<typename VectorType >
void vectorRedux (const VectorType &w)
 
 EIGEN_DECLARE_TEST (redux)
 

Macro Definition Documentation

◆ EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD

#define EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD   8

◆ TEST_ENABLE_TEMPORARY_TRACKING

#define TEST_ENABLE_TEMPORARY_TRACKING

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( redux  )
158  {
159  // the max size cannot be too large, otherwise reduxion operations obviously generate large errors.
160  int maxsize = (std::min)(100, EIGEN_TEST_MAX_SIZE);
161  TEST_SET_BUT_UNUSED_VARIABLE(maxsize);
162  for (int i = 0; i < g_repeat; i++) {
163  CALL_SUBTEST_1(matrixRedux(Matrix<float, 1, 1>()));
164  CALL_SUBTEST_1(matrixRedux(Array<float, 1, 1>()));
165  CALL_SUBTEST_2(matrixRedux(Matrix2f()));
166  CALL_SUBTEST_2(matrixRedux(Array2f()));
167  CALL_SUBTEST_2(matrixRedux(Array22f()));
168  CALL_SUBTEST_3(matrixRedux(Matrix4d()));
169  CALL_SUBTEST_3(matrixRedux(Array4d()));
170  CALL_SUBTEST_3(matrixRedux(Array44d()));
171  CALL_SUBTEST_4(matrixRedux(MatrixXcf(internal::random<int>(1, maxsize), internal::random<int>(1, maxsize))));
172  CALL_SUBTEST_4(matrixRedux(ArrayXXcf(internal::random<int>(1, maxsize), internal::random<int>(1, maxsize))));
173  CALL_SUBTEST_5(matrixRedux(MatrixXd(internal::random<int>(1, maxsize), internal::random<int>(1, maxsize))));
174  CALL_SUBTEST_5(matrixRedux(ArrayXXd(internal::random<int>(1, maxsize), internal::random<int>(1, maxsize))));
175  CALL_SUBTEST_6(matrixRedux(MatrixXi(internal::random<int>(1, maxsize), internal::random<int>(1, maxsize))));
176  CALL_SUBTEST_6(matrixRedux(ArrayXXi(internal::random<int>(1, maxsize), internal::random<int>(1, maxsize))));
177  }
178  for (int i = 0; i < g_repeat; i++) {
179  CALL_SUBTEST_7(vectorRedux(Vector4f()));
180  CALL_SUBTEST_7(vectorRedux(Array4f()));
181  CALL_SUBTEST_5(vectorRedux(VectorXd(internal::random<int>(1, maxsize))));
182  CALL_SUBTEST_5(vectorRedux(ArrayXd(internal::random<int>(1, maxsize))));
183  CALL_SUBTEST_8(vectorRedux(VectorXf(internal::random<int>(1, maxsize))));
184  CALL_SUBTEST_8(vectorRedux(ArrayXf(internal::random<int>(1, maxsize))));
185  }
186 }
i
int i
Definition: BiCGSTAB_step_by_step.cpp:9
maxsize
const size_t maxsize
Definition: benchmark-blocking-sizes.cpp:49
EIGEN_TEST_MAX_SIZE
#define EIGEN_TEST_MAX_SIZE
Definition: boostmultiprec.cpp:16
Eigen::Array
General-purpose arrays with easy API for coefficient-wise operations.
Definition: Array.h:48
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
min
#define min(a, b)
Definition: datatypes.h:22
TEST_SET_BUT_UNUSED_VARIABLE
#define TEST_SET_BUT_UNUSED_VARIABLE(X)
Definition: main.h:139
Eigen::g_repeat
static int g_repeat
Definition: main.h:191
matrixRedux
void matrixRedux(const MatrixType &m)
Definition: redux.cpp:18
vectorRedux
void vectorRedux(const VectorType &w)
Definition: redux.cpp:96
CALL_SUBTEST_6
#define CALL_SUBTEST_6(FUNC)
Definition: split_test_helper.h:34
CALL_SUBTEST_3
#define CALL_SUBTEST_3(FUNC)
Definition: split_test_helper.h:16
CALL_SUBTEST_1
#define CALL_SUBTEST_1(FUNC)
Definition: split_test_helper.h:4
CALL_SUBTEST_8
#define CALL_SUBTEST_8(FUNC)
Definition: split_test_helper.h:46
CALL_SUBTEST_5
#define CALL_SUBTEST_5(FUNC)
Definition: split_test_helper.h:28
CALL_SUBTEST_2
#define CALL_SUBTEST_2(FUNC)
Definition: split_test_helper.h:10
CALL_SUBTEST_7
#define CALL_SUBTEST_7(FUNC)
Definition: split_test_helper.h:40
CALL_SUBTEST_4
#define CALL_SUBTEST_4(FUNC)
Definition: split_test_helper.h:22

References CALL_SUBTEST_1, CALL_SUBTEST_2, CALL_SUBTEST_3, CALL_SUBTEST_4, CALL_SUBTEST_5, CALL_SUBTEST_6, CALL_SUBTEST_7, CALL_SUBTEST_8, EIGEN_TEST_MAX_SIZE, Eigen::g_repeat, i, matrixRedux(), maxsize, min, TEST_SET_BUT_UNUSED_VARIABLE, and vectorRedux().

◆ matrixRedux()

template<typename MatrixType >
void matrixRedux ( const MatrixType &  m)
18  {
19  typedef typename MatrixType::Scalar Scalar;
20  typedef typename MatrixType::RealScalar RealScalar;
21 
22  Index rows = m.rows();
23  Index cols = m.cols();
24 
25  MatrixType m1 = MatrixType::Random(rows, cols);
26 
27  // The entries of m1 are uniformly distributed in [-1,1), so m1.prod() is very small. This may lead to test
28  // failures if we underflow into denormals. Thus, we scale so that entries are close to 1.
29  MatrixType m1_for_prod = MatrixType::Ones(rows, cols) + RealScalar(0.2) * m1;
30 
31  Matrix<Scalar, MatrixType::RowsAtCompileTime, MatrixType::RowsAtCompileTime> m2(rows, rows);
32  m2.setRandom();
33  // Prevent overflows for integer types.
34  if (Eigen::NumTraits<Scalar>::IsInteger) {
35  Scalar kMaxVal = Scalar(10000);
36  m1.array() = m1.array() - kMaxVal * (m1.array() / kMaxVal);
37  m2.array() = m2.array() - kMaxVal * (m2.array() / kMaxVal);
38  }
39 
40  VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::Zero(rows, cols).sum(), Scalar(1));
41  VERIFY_IS_APPROX(
42  MatrixType::Ones(rows, cols).sum(),
43  Scalar(float(
44  rows *
45  cols))); // the float() here to shut up excessive MSVC warning about int->complex conversion being lossy
46  Scalar s(0), p(1), minc(numext::real(m1.coeff(0))), maxc(numext::real(m1.coeff(0)));
47  for (int j = 0; j < cols; j++)
48  for (int i = 0; i < rows; i++) {
49  s += m1(i, j);
50  p *= m1_for_prod(i, j);
51  minc = (std::min)(numext::real(minc), numext::real(m1(i, j)));
52  maxc = (std::max)(numext::real(maxc), numext::real(m1(i, j)));
53  }
54  const Scalar mean = s / Scalar(RealScalar(rows * cols));
55 
56  VERIFY_IS_APPROX(m1.sum(), s);
57  VERIFY_IS_APPROX(m1.mean(), mean);
58  VERIFY_IS_APPROX(m1_for_prod.prod(), p);
59  VERIFY_IS_APPROX(m1.real().minCoeff(), numext::real(minc));
60  VERIFY_IS_APPROX(m1.real().maxCoeff(), numext::real(maxc));
61 
62  // test that partial reduction works if nested expressions is forced to evaluate early
63  VERIFY_IS_APPROX((m1.matrix() * m1.matrix().transpose()).cwiseProduct(m2.matrix()).rowwise().sum().sum(),
64  (m1.matrix() * m1.matrix().transpose()).eval().cwiseProduct(m2.matrix()).rowwise().sum().sum());
65 
66  // test slice vectorization assuming assign is ok
67  Index r0 = internal::random<Index>(0, rows - 1);
68  Index c0 = internal::random<Index>(0, cols - 1);
69  Index r1 = internal::random<Index>(r0 + 1, rows) - r0;
70  Index c1 = internal::random<Index>(c0 + 1, cols) - c0;
71  VERIFY_IS_APPROX(m1.block(r0, c0, r1, c1).sum(), m1.block(r0, c0, r1, c1).eval().sum());
72  VERIFY_IS_APPROX(m1.block(r0, c0, r1, c1).mean(), m1.block(r0, c0, r1, c1).eval().mean());
73  VERIFY_IS_APPROX(m1_for_prod.block(r0, c0, r1, c1).prod(), m1_for_prod.block(r0, c0, r1, c1).eval().prod());
74  VERIFY_IS_APPROX(m1.block(r0, c0, r1, c1).real().minCoeff(), m1.block(r0, c0, r1, c1).real().eval().minCoeff());
75  VERIFY_IS_APPROX(m1.block(r0, c0, r1, c1).real().maxCoeff(), m1.block(r0, c0, r1, c1).real().eval().maxCoeff());
76 
77  // regression for bug 1090
78  const int R1 = MatrixType::RowsAtCompileTime >= 2 ? MatrixType::RowsAtCompileTime / 2 : 6;
79  const int C1 = MatrixType::ColsAtCompileTime >= 2 ? MatrixType::ColsAtCompileTime / 2 : 6;
80  if (R1 <= rows - r0 && C1 <= cols - c0) {
81  VERIFY_IS_APPROX((m1.template block<R1, C1>(r0, c0).sum()), m1.block(r0, c0, R1, C1).sum());
82  }
83 
84  // test empty objects
85  VERIFY_IS_APPROX(m1.block(r0, c0, 0, 0).sum(), Scalar(0));
86  VERIFY_IS_APPROX(m1.block(r0, c0, 0, 0).prod(), Scalar(1));
87 
88  // test nesting complex expression
89  VERIFY_EVALUATION_COUNT((m1.matrix() * m1.matrix().transpose()).sum(),
90  (MatrixType::IsVectorAtCompileTime && MatrixType::SizeAtCompileTime != 1 ? 0 : 1));
91  VERIFY_EVALUATION_COUNT(((m1.matrix() * m1.matrix().transpose()) + m2).sum(),
92  (MatrixType::IsVectorAtCompileTime && MatrixType::SizeAtCompileTime != 1 ? 0 : 1));
93 }
m1
Matrix3d m1
Definition: IOFormat.cpp:2
p
float * p
Definition: Tutorial_Map_using.cpp:9
m2
MatrixType m2(n_dims)
rows
int rows
Definition: Tutorial_commainit_02.cpp:1
cols
int cols
Definition: Tutorial_commainit_02.cpp:1
Scalar
SCALAR Scalar
Definition: bench_gemm.cpp:45
RealScalar
NumTraits< Scalar >::Real RealScalar
Definition: bench_gemm.cpp:46
MatrixType
MatrixXf MatrixType
Definition: benchmark-blocking-sizes.cpp:52
real
float real
Definition: datatypes.h:10
max
#define max(a, b)
Definition: datatypes.h:23
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:13
s
RealScalar s
Definition: level1_cplx_impl.h:130
m
int * m
Definition: level2_cplx_impl.h:294
VERIFY_IS_MUCH_SMALLER_THAN
#define VERIFY_IS_MUCH_SMALLER_THAN(a, b)
Definition: main.h:371
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:83
Global_Physical_Variables::C1
double C1
"Mooney Rivlin" coefficient for generalised Mooney Rivlin law
Definition: TwenteMeshGluing.cpp:74
oomph::PseudoSolidHelper::Zero
double Zero
Definition: pseudosolid_node_update_elements.cc:35
Eigen::NumTraits
Holds information about the various numeric (i.e. scalar) types allowed by Eigen.
Definition: NumTraits.h:217
VERIFY_EVALUATION_COUNT
#define VERIFY_EVALUATION_COUNT(XPR, N)
Definition: test/sparse_product.cpp:28
j
std::ptrdiff_t j
Definition: tut_arithmetic_redux_minmax.cpp:2

References Global_Physical_Variables::C1, cols, i, j, m, m1, m2(), max, min, p, rows, s, VERIFY_EVALUATION_COUNT, VERIFY_IS_APPROX, VERIFY_IS_MUCH_SMALLER_THAN, and oomph::PseudoSolidHelper::Zero.

Referenced by EIGEN_DECLARE_TEST().

◆ vectorRedux()

template<typename VectorType >
void vectorRedux ( const VectorType &  w)
96  {
97  using std::abs;
98  typedef typename VectorType::Scalar Scalar;
99  typedef typename NumTraits<Scalar>::Real RealScalar;
100  Index size = w.size();
101 
102  VectorType v = VectorType::Random(size);
103  VectorType v_for_prod = VectorType::Ones(size) + Scalar(0.2) * v; // see comment above declaration of m1_for_prod
104 
105  for (int i = 1; i < size; i++) {
106  Scalar s(0), p(1);
107  RealScalar minc(numext::real(v.coeff(0))), maxc(numext::real(v.coeff(0)));
108  for (int j = 0; j < i; j++) {
109  s += v[j];
110  p *= v_for_prod[j];
111  minc = (std::min)(minc, numext::real(v[j]));
112  maxc = (std::max)(maxc, numext::real(v[j]));
113  }
114  VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.head(i).sum()), Scalar(1));
115  VERIFY_IS_APPROX(p, v_for_prod.head(i).prod());
116  VERIFY_IS_APPROX(minc, v.real().head(i).minCoeff());
117  VERIFY_IS_APPROX(maxc, v.real().head(i).maxCoeff());
118  }
119 
120  for (int i = 0; i < size - 1; i++) {
121  Scalar s(0), p(1);
122  RealScalar minc(numext::real(v.coeff(i))), maxc(numext::real(v.coeff(i)));
123  for (int j = i; j < size; j++) {
124  s += v[j];
125  p *= v_for_prod[j];
126  minc = (std::min)(minc, numext::real(v[j]));
127  maxc = (std::max)(maxc, numext::real(v[j]));
128  }
129  VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.tail(size - i).sum()), Scalar(1));
130  VERIFY_IS_APPROX(p, v_for_prod.tail(size - i).prod());
131  VERIFY_IS_APPROX(minc, v.real().tail(size - i).minCoeff());
132  VERIFY_IS_APPROX(maxc, v.real().tail(size - i).maxCoeff());
133  }
134 
135  for (int i = 0; i < size / 2; i++) {
136  Scalar s(0), p(1);
137  RealScalar minc(numext::real(v.coeff(i))), maxc(numext::real(v.coeff(i)));
138  for (int j = i; j < size - i; j++) {
139  s += v[j];
140  p *= v_for_prod[j];
141  minc = (std::min)(minc, numext::real(v[j]));
142  maxc = (std::max)(maxc, numext::real(v[j]));
143  }
144  VERIFY_IS_MUCH_SMALLER_THAN(abs(s - v.segment(i, size - 2 * i).sum()), Scalar(1));
145  VERIFY_IS_APPROX(p, v_for_prod.segment(i, size - 2 * i).prod());
146  VERIFY_IS_APPROX(minc, v.real().segment(i, size - 2 * i).minCoeff());
147  VERIFY_IS_APPROX(maxc, v.real().segment(i, size - 2 * i).maxCoeff());
148  }
149 
150  // test empty objects
151  VERIFY_IS_APPROX(v.head(0).sum(), Scalar(0));
152  VERIFY_IS_APPROX(v.tail(0).prod(), Scalar(1));
153  VERIFY_RAISES_ASSERT(v.head(0).mean());
154  VERIFY_RAISES_ASSERT(v.head(0).minCoeff());
155  VERIFY_RAISES_ASSERT(v.head(0).maxCoeff());
156 }
abs
AnnoyingScalar abs(const AnnoyingScalar &x)
Definition: AnnoyingScalar.h:135
v
Array< int, Dynamic, 1 > v
Definition: Array_initializer_list_vector_cxx11.cpp:1
w
RowVector3d w
Definition: Matrix_resize_int.cpp:3
size
Scalar Scalar int size
Definition: benchVecAdd.cpp:17
VERIFY_RAISES_ASSERT
#define VERIFY_RAISES_ASSERT(a)
Definition: main.h:329
VectorType
Definition: fft_test_shared.h:66

References abs(), i, j, max, min, p, s, size, v, VERIFY_IS_APPROX, VERIFY_IS_MUCH_SMALLER_THAN, VERIFY_RAISES_ASSERT, and w.

Referenced by EIGEN_DECLARE_TEST().