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

Namespaces

 Eigen
 Namespace containing all symbols from the Eigen library.
 
 Eigen::internal
 Namespace containing low-level routines from the Eigen library.
 

Macros

#define VERIFY_IS_APPROX_EVALUATOR(DEST, EXPR)   VERIFY_IS_APPROX(copy_using_evaluator(DEST, (EXPR)), (EXPR).eval());
 
#define VERIFY_IS_APPROX_EVALUATOR2(DEST, EXPR, REF)   VERIFY_IS_APPROX(copy_using_evaluator(DEST, (EXPR)), (REF).eval());
 

Functions

template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs > Eigen::prod (const Lhs &lhs, const Rhs &rhs)
 
template<typename Lhs , typename Rhs >
const Product< Lhs, Rhs, LazyProduct > Eigen::lazyprod (const Lhs &lhs, const Rhs &rhs)
 
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType & Eigen::copy_using_evaluator (const EigenBase< DstXprType > &dst, const SrcXprType &src)
 
template<typename DstXprType , template< typename > class StorageBase, typename SrcXprType >
EIGEN_STRONG_INLINE const DstXprType & Eigen::copy_using_evaluator (const NoAlias< DstXprType, StorageBase > &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
EIGEN_STRONG_INLINE DstXprType & Eigen::copy_using_evaluator (const PlainObjectBase< DstXprType > &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
void Eigen::add_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
void Eigen::subtract_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
void Eigen::multiply_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
void Eigen::divide_assign_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename DstXprType , typename SrcXprType >
void Eigen::swap_using_evaluator (const DstXprType &dst, const SrcXprType &src)
 
template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >
EIGEN_DEVICE_FUNC void Eigen::internal::call_assignment (const NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
 
template<typename Dst , template< typename > class StorageBase, typename Src , typename Func >
EIGEN_DEVICE_FUNC void Eigen::internal::call_restricted_packet_assignment (const NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
 
template<typename XprType >
long get_cost (const XprType &)
 
 EIGEN_DECLARE_TEST (evaluators)
 

Macro Definition Documentation

◆ VERIFY_IS_APPROX_EVALUATOR

#define VERIFY_IS_APPROX_EVALUATOR (   DEST,
  EXPR 
)    VERIFY_IS_APPROX(copy_using_evaluator(DEST, (EXPR)), (EXPR).eval());

◆ VERIFY_IS_APPROX_EVALUATOR2

#define VERIFY_IS_APPROX_EVALUATOR2 (   DEST,
  EXPR,
  REF 
)    VERIFY_IS_APPROX(copy_using_evaluator(DEST, (EXPR)), (REF).eval());

Function Documentation

◆ EIGEN_DECLARE_TEST()

EIGEN_DECLARE_TEST ( evaluators  )
104  {
105  // Testing Matrix evaluator and Transpose
106  Vector2d v = Vector2d::Random();
107  const Vector2d v_const(v);
108  Vector2d v2;
109  RowVector2d w;
110 
111  VERIFY_IS_APPROX_EVALUATOR(v2, v);
112  VERIFY_IS_APPROX_EVALUATOR(v2, v_const);
113 
114  // Testing Transpose
115  VERIFY_IS_APPROX_EVALUATOR(w, v.transpose()); // Transpose as rvalue
116  VERIFY_IS_APPROX_EVALUATOR(w, v_const.transpose());
117 
118  copy_using_evaluator(w.transpose(), v); // Transpose as lvalue
119  VERIFY_IS_APPROX(w, v.transpose().eval());
120 
121  copy_using_evaluator(w.transpose(), v_const);
122  VERIFY_IS_APPROX(w, v_const.transpose().eval());
123 
124  // Testing Array evaluator
125  {
126  ArrayXXf a(2, 3);
127  ArrayXXf b(3, 2);
128  a << 1, 2, 3, 4, 5, 6;
129  const ArrayXXf a_const(a);
130 
131  VERIFY_IS_APPROX_EVALUATOR(b, a.transpose());
132 
133  VERIFY_IS_APPROX_EVALUATOR(b, a_const.transpose());
134 
135  // Testing CwiseNullaryOp evaluator
136  copy_using_evaluator(w, RowVector2d::Random());
137  VERIFY((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ...
138 
139  VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Zero());
140 
141  VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Constant(3));
142 
143  // mix CwiseNullaryOp and transpose
144  VERIFY_IS_APPROX_EVALUATOR(w, Vector2d::Zero().transpose());
145  }
146 
147  {
148  // test product expressions
149  int s = internal::random<int>(1, 100);
150  MatrixXf a(s, s), b(s, s), c(s, s), d(s, s);
151  a.setRandom();
152  b.setRandom();
153  c.setRandom();
154  d.setRandom();
155  VERIFY_IS_APPROX_EVALUATOR(d, (a + b));
156  VERIFY_IS_APPROX_EVALUATOR(d, (a + b).transpose());
157  VERIFY_IS_APPROX_EVALUATOR2(d, prod(a, b), a * b);
158  VERIFY_IS_APPROX_EVALUATOR2(d.noalias(), prod(a, b), a * b);
159  VERIFY_IS_APPROX_EVALUATOR2(d, prod(a, b) + c, a * b + c);
160  VERIFY_IS_APPROX_EVALUATOR2(d, s * prod(a, b), s * a * b);
161  VERIFY_IS_APPROX_EVALUATOR2(d, prod(a, b).transpose(), (a * b).transpose());
162  VERIFY_IS_APPROX_EVALUATOR2(d, prod(a, b) + prod(b, c), a * b + b * c);
163 
164  // check that prod works even with aliasing present
165  c = a * a;
166  copy_using_evaluator(a, prod(a, a));
167  VERIFY_IS_APPROX(a, c);
168 
169  // check compound assignment of products
170  d = c;
171  add_assign_using_evaluator(c.noalias(), prod(a, b));
172  d.noalias() += a * b;
173  VERIFY_IS_APPROX(c, d);
174 
175  d = c;
176  subtract_assign_using_evaluator(c.noalias(), prod(a, b));
177  d.noalias() -= a * b;
178  VERIFY_IS_APPROX(c, d);
179  }
180 
181  {
182  // test product with all possible sizes
183  int s = internal::random<int>(1, 100);
184  Matrix<float, 1, 1> m11, res11;
185  m11.setRandom(1, 1);
186  Matrix<float, 1, 4> m14, res14;
187  m14.setRandom(1, 4);
188  Matrix<float, 1, Dynamic> m1X, res1X;
189  m1X.setRandom(1, s);
190  Matrix<float, 4, 1> m41, res41;
191  m41.setRandom(4, 1);
192  Matrix<float, 4, 4> m44, res44;
193  m44.setRandom(4, 4);
194  Matrix<float, 4, Dynamic> m4X, res4X;
195  m4X.setRandom(4, s);
196  Matrix<float, Dynamic, 1> mX1, resX1;
197  mX1.setRandom(s, 1);
198  Matrix<float, Dynamic, 4> mX4, resX4;
199  mX4.setRandom(s, 4);
200  Matrix<float, Dynamic, Dynamic> mXX, resXX;
201  mXX.setRandom(s, s);
202 
203  VERIFY_IS_APPROX_EVALUATOR2(res11, prod(m11, m11), m11 * m11);
204  VERIFY_IS_APPROX_EVALUATOR2(res11, prod(m14, m41), m14 * m41);
205  VERIFY_IS_APPROX_EVALUATOR2(res11, prod(m1X, mX1), m1X * mX1);
206  VERIFY_IS_APPROX_EVALUATOR2(res14, prod(m11, m14), m11 * m14);
207  VERIFY_IS_APPROX_EVALUATOR2(res14, prod(m14, m44), m14 * m44);
208  VERIFY_IS_APPROX_EVALUATOR2(res14, prod(m1X, mX4), m1X * mX4);
209  VERIFY_IS_APPROX_EVALUATOR2(res1X, prod(m11, m1X), m11 * m1X);
210  VERIFY_IS_APPROX_EVALUATOR2(res1X, prod(m14, m4X), m14 * m4X);
211  VERIFY_IS_APPROX_EVALUATOR2(res1X, prod(m1X, mXX), m1X * mXX);
212  VERIFY_IS_APPROX_EVALUATOR2(res41, prod(m41, m11), m41 * m11);
213  VERIFY_IS_APPROX_EVALUATOR2(res41, prod(m44, m41), m44 * m41);
214  VERIFY_IS_APPROX_EVALUATOR2(res41, prod(m4X, mX1), m4X * mX1);
215  VERIFY_IS_APPROX_EVALUATOR2(res44, prod(m41, m14), m41 * m14);
216  VERIFY_IS_APPROX_EVALUATOR2(res44, prod(m44, m44), m44 * m44);
217  VERIFY_IS_APPROX_EVALUATOR2(res44, prod(m4X, mX4), m4X * mX4);
218  VERIFY_IS_APPROX_EVALUATOR2(res4X, prod(m41, m1X), m41 * m1X);
219  VERIFY_IS_APPROX_EVALUATOR2(res4X, prod(m44, m4X), m44 * m4X);
220  VERIFY_IS_APPROX_EVALUATOR2(res4X, prod(m4X, mXX), m4X * mXX);
221  VERIFY_IS_APPROX_EVALUATOR2(resX1, prod(mX1, m11), mX1 * m11);
222  VERIFY_IS_APPROX_EVALUATOR2(resX1, prod(mX4, m41), mX4 * m41);
223  VERIFY_IS_APPROX_EVALUATOR2(resX1, prod(mXX, mX1), mXX * mX1);
224  VERIFY_IS_APPROX_EVALUATOR2(resX4, prod(mX1, m14), mX1 * m14);
225  VERIFY_IS_APPROX_EVALUATOR2(resX4, prod(mX4, m44), mX4 * m44);
226  VERIFY_IS_APPROX_EVALUATOR2(resX4, prod(mXX, mX4), mXX * mX4);
227  VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mX1, m1X), mX1 * m1X);
228  VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mX4, m4X), mX4 * m4X);
229  VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mXX, mXX), mXX * mXX);
230  }
231 
232  {
233  ArrayXXf a(2, 3);
234  ArrayXXf b(3, 2);
235  a << 1, 2, 3, 4, 5, 6;
236  const ArrayXXf a_const(a);
237 
238  // this does not work because Random is eval-before-nested:
239  // copy_using_evaluator(w, Vector2d::Random().transpose());
240 
241  // test CwiseUnaryOp
242  VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v);
243  VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose());
244  VERIFY_IS_APPROX_EVALUATOR(b, (a + 3).transpose());
245  VERIFY_IS_APPROX_EVALUATOR(b, (2 * a_const + 3).transpose());
246 
247  // test CwiseBinaryOp
248  VERIFY_IS_APPROX_EVALUATOR(v2, v + Vector2d::Ones());
249  VERIFY_IS_APPROX_EVALUATOR(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3)));
250 
251  // dynamic matrices and arrays
252  MatrixXd mat1(6, 6), mat2(6, 6);
253  VERIFY_IS_APPROX_EVALUATOR(mat1, MatrixXd::Identity(6, 6));
254  VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
255  copy_using_evaluator(mat2.transpose(), mat1);
256  VERIFY_IS_APPROX(mat2.transpose(), mat1);
257 
258  ArrayXXd arr1(6, 6), arr2(6, 6);
259  VERIFY_IS_APPROX_EVALUATOR(arr1, ArrayXXd::Constant(6, 6, 3.0));
260  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
261 
262  // test automatic resizing
263  mat2.resize(3, 3);
264  VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
265  arr2.resize(9, 9);
266  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
267 
268  // test direct traversal
269  Matrix3f m3;
270  Array33f a3;
271  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity()); // matrix, nullary
272  // TODO: find a way to test direct traversal with array
273  VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Identity().transpose()); // transpose
274  VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Identity()); // unary
275  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity() + Matrix3f::Zero()); // binary
276  VERIFY_IS_APPROX_EVALUATOR(m3.block(0, 0, 2, 2), Matrix3f::Identity().block(1, 1, 2, 2)); // block
277 
278  // test linear traversal
279  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero()); // matrix, nullary
280  VERIFY_IS_APPROX_EVALUATOR(a3, Array33f::Zero()); // array
281  VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Zero().transpose()); // transpose
282  VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Zero()); // unary
283  VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero() + m3); // binary
284 
285  // test inner vectorization
286  Matrix4f m4, m4src = Matrix4f::Random();
287  Array44f a4, a4src = Matrix4f::Random();
288  VERIFY_IS_APPROX_EVALUATOR(m4, m4src); // matrix
289  VERIFY_IS_APPROX_EVALUATOR(a4, a4src); // array
290  VERIFY_IS_APPROX_EVALUATOR(m4.transpose(), m4src.transpose()); // transpose
291  // TODO: find out why Matrix4f::Zero() does not allow inner vectorization
292  VERIFY_IS_APPROX_EVALUATOR(m4, 2 * m4src); // unary
293  VERIFY_IS_APPROX_EVALUATOR(m4, m4src + m4src); // binary
294 
295  // test linear vectorization
296  MatrixXf mX(6, 6), mXsrc = MatrixXf::Random(6, 6);
297  ArrayXXf aX(6, 6), aXsrc = ArrayXXf::Random(6, 6);
298  VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc); // matrix
299  VERIFY_IS_APPROX_EVALUATOR(aX, aXsrc); // array
300  VERIFY_IS_APPROX_EVALUATOR(mX.transpose(), mXsrc.transpose()); // transpose
301  VERIFY_IS_APPROX_EVALUATOR(mX, MatrixXf::Zero(6, 6)); // nullary
302  VERIFY_IS_APPROX_EVALUATOR(mX, 2 * mXsrc); // unary
303  VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc + mXsrc); // binary
304 
305  // test blocks and slice vectorization
306  VERIFY_IS_APPROX_EVALUATOR(m4, (mXsrc.block<4, 4>(1, 0)));
307  VERIFY_IS_APPROX_EVALUATOR(aX, ArrayXXf::Constant(10, 10, 3.0).block(2, 3, 6, 6));
308 
309  Matrix4f m4ref = m4;
310  copy_using_evaluator(m4.block(1, 1, 2, 3), m3.bottomRows(2));
311  m4ref.block(1, 1, 2, 3) = m3.bottomRows(2);
312  VERIFY_IS_APPROX(m4, m4ref);
313 
314  mX.setIdentity(20, 20);
315  MatrixXf mXref = MatrixXf::Identity(20, 20);
316  mXsrc = MatrixXf::Random(9, 12);
317  copy_using_evaluator(mX.block(4, 4, 9, 12), mXsrc);
318  mXref.block(4, 4, 9, 12) = mXsrc;
319  VERIFY_IS_APPROX(mX, mXref);
320 
321  // test Map
322  const float raw[3] = {1, 2, 3};
323  float buffer[3] = {0, 0, 0};
324  Vector3f v3;
325  Array3f a3f;
326  VERIFY_IS_APPROX_EVALUATOR(v3, Map<const Vector3f>(raw));
327  VERIFY_IS_APPROX_EVALUATOR(a3f, Map<const Array3f>(raw));
328  Vector3f::Map(buffer) = 2 * v3;
329  VERIFY(buffer[0] == 2);
330  VERIFY(buffer[1] == 4);
331  VERIFY(buffer[2] == 6);
332 
333  // test CwiseUnaryView
334  mat1.setRandom();
335  mat2.setIdentity();
336  MatrixXcd matXcd(6, 6), matXcd_ref(6, 6);
337  copy_using_evaluator(matXcd.real(), mat1);
338  copy_using_evaluator(matXcd.imag(), mat2);
339  matXcd_ref.real() = mat1;
340  matXcd_ref.imag() = mat2;
341  VERIFY_IS_APPROX(matXcd, matXcd_ref);
342 
343  // test Select
344  VERIFY_IS_APPROX_EVALUATOR(aX, (aXsrc > 0).select(aXsrc, -aXsrc));
345 
346  // test Replicate
347  mXsrc = MatrixXf::Random(6, 6);
348  VectorXf vX = VectorXf::Random(6);
349  mX.resize(6, 6);
350  VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc.colwise() + vX);
351  matXcd.resize(12, 12);
352  VERIFY_IS_APPROX_EVALUATOR(matXcd, matXcd_ref.replicate(2, 2));
353  VERIFY_IS_APPROX_EVALUATOR(matXcd, (matXcd_ref.replicate<2, 2>()));
354 
355  // test partial reductions
356  VectorXd vec1(6);
357  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.rowwise().sum());
358  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.colwise().sum().transpose());
359 
360  // test MatrixWrapper and ArrayWrapper
361  mat1.setRandom(6, 6);
362  arr1.setRandom(6, 6);
363  VERIFY_IS_APPROX_EVALUATOR(mat2, arr1.matrix());
364  VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array());
365  VERIFY_IS_APPROX_EVALUATOR(mat2, (arr1 + 2).matrix());
366  VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array() + 2);
367  mat2.array() = arr1 * arr1;
368  VERIFY_IS_APPROX(mat2, (arr1 * arr1).matrix());
369  arr2.matrix() = MatrixXd::Identity(6, 6);
370  VERIFY_IS_APPROX(arr2, MatrixXd::Identity(6, 6).array());
371 
372  // test Reverse
373  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.reverse());
374  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.colwise().reverse());
375  VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.rowwise().reverse());
376  arr2.reverse() = arr1;
377  VERIFY_IS_APPROX(arr2, arr1.reverse());
378  mat2.array() = mat1.array().reverse();
379  VERIFY_IS_APPROX(mat2.array(), mat1.array().reverse());
380 
381  // test Diagonal
382  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal());
383  vec1.resize(5);
384  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal(1));
385  VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal<-1>());
386  vec1.setRandom();
387 
388  mat2 = mat1;
389  copy_using_evaluator(mat1.diagonal(1), vec1);
390  mat2.diagonal(1) = vec1;
391  VERIFY_IS_APPROX(mat1, mat2);
392 
393  copy_using_evaluator(mat1.diagonal<-1>(), mat1.diagonal(1));
394  mat2.diagonal<-1>() = mat2.diagonal(1);
395  VERIFY_IS_APPROX(mat1, mat2);
396  }
397 
398  {
399  // test swapping
400  MatrixXd mat1, mat2, mat1ref, mat2ref;
401  mat1ref = mat1 = MatrixXd::Random(6, 6);
402  mat2ref = mat2 = 2 * mat1 + MatrixXd::Identity(6, 6);
403  swap_using_evaluator(mat1, mat2);
404  mat1ref.swap(mat2ref);
405  VERIFY_IS_APPROX(mat1, mat1ref);
406  VERIFY_IS_APPROX(mat2, mat2ref);
407 
408  swap_using_evaluator(mat1.block(0, 0, 3, 3), mat2.block(3, 3, 3, 3));
409  mat1ref.block(0, 0, 3, 3).swap(mat2ref.block(3, 3, 3, 3));
410  VERIFY_IS_APPROX(mat1, mat1ref);
411  VERIFY_IS_APPROX(mat2, mat2ref);
412 
413  swap_using_evaluator(mat1.row(2), mat2.col(3).transpose());
414  mat1.row(2).swap(mat2.col(3).transpose());
415  VERIFY_IS_APPROX(mat1, mat1ref);
416  VERIFY_IS_APPROX(mat2, mat2ref);
417  }
418 
419  {
420  // test compound assignment
421  const Matrix4d mat_const = Matrix4d::Random();
422  Matrix4d mat, mat_ref;
423  mat = mat_ref = Matrix4d::Identity();
424  add_assign_using_evaluator(mat, mat_const);
425  mat_ref += mat_const;
426  VERIFY_IS_APPROX(mat, mat_ref);
427 
428  subtract_assign_using_evaluator(mat.row(1), 2 * mat.row(2));
429  mat_ref.row(1) -= 2 * mat_ref.row(2);
430  VERIFY_IS_APPROX(mat, mat_ref);
431 
432  const ArrayXXf arr_const = ArrayXXf::Random(5, 3);
433  ArrayXXf arr, arr_ref;
434  arr = arr_ref = ArrayXXf::Constant(5, 3, 0.5);
435  multiply_assign_using_evaluator(arr, arr_const);
436  arr_ref *= arr_const;
437  VERIFY_IS_APPROX(arr, arr_ref);
438 
439  divide_assign_using_evaluator(arr.row(1), arr.row(2) + 1);
440  arr_ref.row(1) /= (arr_ref.row(2) + 1);
441  VERIFY_IS_APPROX(arr, arr_ref);
442  }
443 
444  {
445  // test triangular shapes
446  MatrixXd A = MatrixXd::Random(6, 6), B(6, 6), C(6, 6), D(6, 6);
447  A.setRandom();
448  B.setRandom();
449  VERIFY_IS_APPROX_EVALUATOR2(B, A.triangularView<Upper>(), MatrixXd(A.triangularView<Upper>()));
450 
451  A.setRandom();
452  B.setRandom();
453  VERIFY_IS_APPROX_EVALUATOR2(B, A.triangularView<UnitLower>(), MatrixXd(A.triangularView<UnitLower>()));
454 
455  A.setRandom();
456  B.setRandom();
457  VERIFY_IS_APPROX_EVALUATOR2(B, A.triangularView<UnitUpper>(), MatrixXd(A.triangularView<UnitUpper>()));
458 
459  A.setRandom();
460  B.setRandom();
461  C = B;
462  C.triangularView<Upper>() = A;
463  copy_using_evaluator(B.triangularView<Upper>(), A);
464  VERIFY(B.isApprox(C) && "copy_using_evaluator(B.triangularView<Upper>(), A)");
465 
466  A.setRandom();
467  B.setRandom();
468  C = B;
469  C.triangularView<Lower>() = A.triangularView<Lower>();
470  copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Lower>());
471  VERIFY(B.isApprox(C) && "copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Lower>())");
472 
473  A.setRandom();
474  B.setRandom();
475  C = B;
476  C.triangularView<Lower>() = A.triangularView<Upper>().transpose();
477  copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Upper>().transpose());
478  VERIFY(B.isApprox(C) && "copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Lower>().transpose())");
479 
480  A.setRandom();
481  B.setRandom();
482  C = B;
483  D = A;
484  C.triangularView<Upper>().swap(D.triangularView<Upper>());
485  swap_using_evaluator(B.triangularView<Upper>(), A.triangularView<Upper>());
486  VERIFY(B.isApprox(C) && "swap_using_evaluator(B.triangularView<Upper>(), A.triangularView<Upper>())");
487 
488  VERIFY_IS_APPROX_EVALUATOR2(B, prod(A.triangularView<Upper>(), A), MatrixXd(A.triangularView<Upper>() * A));
489 
490  VERIFY_IS_APPROX_EVALUATOR2(B, prod(A.selfadjointView<Upper>(), A), MatrixXd(A.selfadjointView<Upper>() * A));
491  }
492 
493  {
494  // test diagonal shapes
495  VectorXd d = VectorXd::Random(6);
496  MatrixXd A = MatrixXd::Random(6, 6), B(6, 6);
497  A.setRandom();
498  B.setRandom();
499 
500  VERIFY_IS_APPROX_EVALUATOR2(B, lazyprod(d.asDiagonal(), A), MatrixXd(d.asDiagonal() * A));
501  VERIFY_IS_APPROX_EVALUATOR2(B, lazyprod(A, d.asDiagonal()), MatrixXd(A * d.asDiagonal()));
502  }
503 
504  {
505  // test CoeffReadCost
506  Matrix4d a, b;
507  VERIFY_IS_EQUAL(get_cost(a), 1);
508  VERIFY_IS_EQUAL(get_cost(a + b), 3);
509  VERIFY_IS_EQUAL(get_cost(2 * a + b), 4);
510  VERIFY_IS_EQUAL(get_cost(a * b), 1);
511  VERIFY_IS_EQUAL(get_cost(a.lazyProduct(b)), 15);
512  VERIFY_IS_EQUAL(get_cost(a * (a * b)), 1);
513  VERIFY_IS_EQUAL(get_cost(a.lazyProduct(a * b)), 15);
514  VERIFY_IS_EQUAL(get_cost(a * (a + b)), 1);
515  VERIFY_IS_EQUAL(get_cost(a.lazyProduct(a + b)), 15);
516  }
517 
518  // regression test for PR 544 and bug 1622 (introduced in #71609c4)
519  {
520  // test restricted_packet_assignment with an unaligned destination
521  const size_t M = 2;
522  const size_t K = 2;
523  const size_t N = 5;
524  float* destMem = new float[(M * N) + 1];
525  // In case of no alignment, avoid division by zero.
526  constexpr int alignment = (std::max<int>)(EIGEN_MAX_ALIGN_BYTES, 1);
527  float* dest = (std::uintptr_t(destMem) % alignment) == 0 ? destMem + 1 : destMem;
528 
529  const Matrix<float, Dynamic, Dynamic, RowMajor> a = Matrix<float, Dynamic, Dynamic, RowMajor>::Random(M, K);
530  const Matrix<float, Dynamic, Dynamic, RowMajor> b = Matrix<float, Dynamic, Dynamic, RowMajor>::Random(K, N);
531 
532  Map<Matrix<float, Dynamic, Dynamic, RowMajor> > z(dest, M, N);
533  ;
534  Product<Matrix<float, Dynamic, Dynamic, RowMajor>, Matrix<float, Dynamic, Dynamic, RowMajor>, LazyProduct> tmp(a,
535  b);
536  internal::call_restricted_packet_assignment(z.noalias(), tmp.derived(), internal::assign_op<float, float>());
537 
538  VERIFY_IS_APPROX(z, a * b);
539  delete[] destMem;
540  }
541 }
v
Array< int, Dynamic, 1 > v
Definition: Array_initializer_list_vector_cxx11.cpp:1
EIGEN_MAX_ALIGN_BYTES
#define EIGEN_MAX_ALIGN_BYTES
Definition: ConfigureVectorization.h:163
D
dominoes D
Definition: Domino.cpp:55
mat
Eigen::SparseMatrix< double > mat
Definition: EigenUnitTest.cpp:10
w
RowVector3d w
Definition: Matrix_resize_int.cpp:3
vec1
RowVectorXd vec1(3)
mat1
MatrixXd mat1(size, size)
v2
Map< RowVectorXf > v2(M2.data(), M2.size())
block
m m block(1, 0, 2, 2)<< 4
b
Scalar * b
Definition: benchVecAdd.cpp:17
A
Matrix< SCALARA, Dynamic, Dynamic, opt_A > A
Definition: bench_gemm.cpp:47
C
Matrix< Scalar, Dynamic, Dynamic > C
Definition: bench_gemm.cpp:49
B
Matrix< SCALARB, Dynamic, Dynamic, opt_B > B
Definition: bench_gemm.cpp:48
Eigen::Map
A matrix or vector expression mapping an existing array of data.
Definition: Map.h:96
Eigen::Matrix
The matrix class, also used for vectors and row-vectors.
Definition: Eigen/Eigen/src/Core/Matrix.h:186
Eigen::PlainObjectBase::setRandom
Derived & setRandom(Index size)
Definition: Random.h:147
Eigen::Product
Expression of the product of two arbitrary matrices or vectors.
Definition: Product.h:202
oomph::Matrix
Definition: matrices.h:74
matrix
Eigen::Map< Eigen::Matrix< T, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor >, 0, Eigen::OuterStride<> > matrix(T *data, int rows, int cols, int stride)
Definition: common.h:85
N
@ N
Definition: constructor.cpp:22
VERIFY_IS_APPROX_EVALUATOR
#define VERIFY_IS_APPROX_EVALUATOR(DEST, EXPR)
Definition: evaluators.cpp:101
VERIFY_IS_APPROX_EVALUATOR2
#define VERIFY_IS_APPROX_EVALUATOR2(DEST, EXPR, REF)
Definition: evaluators.cpp:102
get_cost
long get_cost(const XprType &)
Definition: evaluators.cpp:95
Eigen::LazyProduct
@ LazyProduct
Definition: Constants.h:504
Eigen::UnitLower
@ UnitLower
Definition: Constants.h:219
Eigen::UnitUpper
@ UnitUpper
Definition: Constants.h:221
Eigen::Lower
@ Lower
Definition: Constants.h:211
Eigen::Upper
@ Upper
Definition: Constants.h:213
VERIFY_IS_APPROX
#define VERIFY_IS_APPROX(a, b)
Definition: integer_types.cpp:13
s
RealScalar s
Definition: level1_cplx_impl.h:130
swap
EIGEN_BLAS_FUNC() swap(int *n, RealScalar *px, int *incx, RealScalar *py, int *incy)
Definition: level1_impl.h:117
a
const Scalar * a
Definition: level2_cplx_impl.h:32
tmp
Eigen::Matrix< Scalar, Dynamic, Dynamic, ColMajor > tmp
Definition: level3_impl.h:365
VERIFY
#define VERIFY(a)
Definition: main.h:362
VERIFY_IS_EQUAL
#define VERIFY_IS_EQUAL(a, b)
Definition: main.h:367
Eigen::internal::call_restricted_packet_assignment
EIGEN_DEVICE_FUNC void call_restricted_packet_assignment(const NoAlias< Dst, StorageBase > &dst, const Src &src, const Func &func)
Definition: evaluators.cpp:86
Eigen::copy_using_evaluator
EIGEN_STRONG_INLINE DstXprType & copy_using_evaluator(const PlainObjectBase< DstXprType > &dst, const SrcXprType &src)
Definition: evaluators.cpp:31
Eigen::array
std::array< T, N > array
Definition: EmulateArray.h:231
Eigen::subtract_assign_using_evaluator
void subtract_assign_using_evaluator(const DstXprType &dst, const SrcXprType &src)
Definition: evaluators.cpp:53
Eigen::swap_using_evaluator
void swap_using_evaluator(const DstXprType &dst, const SrcXprType &src)
Definition: evaluators.cpp:74
Eigen::lazyprod
const Product< Lhs, Rhs, LazyProduct > lazyprod(const Lhs &lhs, const Rhs &rhs)
Definition: evaluators.cpp:12
Eigen::multiply_assign_using_evaluator
void multiply_assign_using_evaluator(const DstXprType &dst, const SrcXprType &src)
Definition: evaluators.cpp:60
Eigen::divide_assign_using_evaluator
void divide_assign_using_evaluator(const DstXprType &dst, const SrcXprType &src)
Definition: evaluators.cpp:67
Eigen::add_assign_using_evaluator
void add_assign_using_evaluator(const DstXprType &dst, const SrcXprType &src)
Definition: evaluators.cpp:46
PlanarWave::K
double K
Wave number.
Definition: sphere_scattering.cc:115
anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose
void transpose()
Definition: skew_symmetric_matrix3.cpp:135
calibrate.c
int c
Definition: calibrate.py:100
oomph::PseudoSolidHelper::Zero
double Zero
Definition: pseudosolid_node_update_elements.cc:35
prod
EIGEN_DONT_INLINE void prod(const Lhs &a, const Rhs &b, Res &c)
Definition: product_threshold.cpp:53

References a, Eigen::add_assign_using_evaluator(), b, block(), calibrate::c, Eigen::internal::call_restricted_packet_assignment(), Eigen::copy_using_evaluator(), D, Eigen::divide_assign_using_evaluator(), EIGEN_MAX_ALIGN_BYTES, get_cost(), PlanarWave::K, Eigen::lazyprod(), Eigen::LazyProduct, Eigen::Lower, mat1(), matrix(), Eigen::multiply_assign_using_evaluator(), N, prod(), s, Eigen::PlainObjectBase< Derived >::setRandom(), Eigen::subtract_assign_using_evaluator(), swap(), Eigen::swap_using_evaluator(), tmp, anonymous_namespace{skew_symmetric_matrix3.cpp}::transpose(), Eigen::UnitLower, Eigen::UnitUpper, Eigen::Upper, v, v2(), vec1(), VERIFY, VERIFY_IS_APPROX, VERIFY_IS_APPROX_EVALUATOR, VERIFY_IS_APPROX_EVALUATOR2, VERIFY_IS_EQUAL, w, and oomph::PseudoSolidHelper::Zero.

◆ get_cost()

template<typename XprType >
long get_cost ( const XprType &  )
95  {
96  return Eigen::internal::evaluator<XprType>::CoeffReadCost;
97 }
Eigen::internal::evaluator
Definition: CoreEvaluators.h:104

Referenced by EIGEN_DECLARE_TEST().