ground/gcs/src/libs/eigen/test/evaluators.cpp

   1
   2 #include "main.h"
   3
   4 namespace Eigen {
   5
   6   template<typename Lhs,typename Rhs>
   7   const Product<Lhs,Rhs>
   8   prod(const Lhs& lhs, const Rhs& rhs)
   9   {
  10     return Product<Lhs,Rhs>(lhs,rhs);
  11   }
  12
  13   template<typename Lhs,typename Rhs>
  14   const Product<Lhs,Rhs,LazyProduct>
  15   lazyprod(const Lhs& lhs, const Rhs& rhs)
  16   {
  17     return Product<Lhs,Rhs,LazyProduct>(lhs,rhs);
  18   }
  19
  20   template<typename DstXprType, typename SrcXprType>
  21   EIGEN_STRONG_INLINE
  22   DstXprType& copy_using_evaluator(const EigenBase<DstXprType> &dst, const SrcXprType &src)
  23   {
  24     call_assignment(dst.const_cast_derived(), src.derived(), internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
  25     return dst.const_cast_derived();
  26   }
  27
  28   template<typename DstXprType, template <typename> class StorageBase, typename SrcXprType>
  29   EIGEN_STRONG_INLINE
  30   const DstXprType& copy_using_evaluator(const NoAlias<DstXprType, StorageBase>& dst, const SrcXprType &src)
  31   {
  32     call_assignment(dst, src.derived(), internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
  33     return dst.expression();
  34   }
  35
  36   template<typename DstXprType, typename SrcXprType>
  37   EIGEN_STRONG_INLINE
  38   DstXprType& copy_using_evaluator(const PlainObjectBase<DstXprType> &dst, const SrcXprType &src)
  39   {
  40     #ifdef EIGEN_NO_AUTOMATIC_RESIZING
  41     eigen_assert((dst.size()==0 || (IsVectorAtCompileTime ? (dst.size() == src.size())
  42                                                           : (dst.rows() == src.rows() && dst.cols() == src.cols())))
  43                 && "Size mismatch. Automatic resizing is disabled because EIGEN_NO_AUTOMATIC_RESIZING is defined");
  44   #else
  45     dst.const_cast_derived().resizeLike(src.derived());
  46   #endif
  47
  48     call_assignment(dst.const_cast_derived(), src.derived(), internal::assign_op<typename DstXprType::Scalar,typename SrcXprType::Scalar>());
  49     return dst.const_cast_derived();
  50   }
  51
  52   template<typename DstXprType, typename SrcXprType>
  53   void add_assign_using_evaluator(const DstXprType& dst, const SrcXprType& src)
  54   {
  55     typedef typename DstXprType::Scalar Scalar;
  56     call_assignment(const_cast<DstXprType&>(dst), src.derived(), internal::add_assign_op<Scalar,typename SrcXprType::Scalar>());
  57   }
  58
  59   template<typename DstXprType, typename SrcXprType>
  60   void subtract_assign_using_evaluator(const DstXprType& dst, const SrcXprType& src)
  61   {
  62     typedef typename DstXprType::Scalar Scalar;
  63     call_assignment(const_cast<DstXprType&>(dst), src.derived(), internal::sub_assign_op<Scalar,typename SrcXprType::Scalar>());
  64   }
  65
  66   template<typename DstXprType, typename SrcXprType>
  67   void multiply_assign_using_evaluator(const DstXprType& dst, const SrcXprType& src)
  68   {
  69     typedef typename DstXprType::Scalar Scalar;
  70     call_assignment(dst.const_cast_derived(), src.derived(), internal::mul_assign_op<Scalar,typename SrcXprType::Scalar>());
  71   }
  72
  73   template<typename DstXprType, typename SrcXprType>
  74   void divide_assign_using_evaluator(const DstXprType& dst, const SrcXprType& src)
  75   {
  76     typedef typename DstXprType::Scalar Scalar;
  77     call_assignment(dst.const_cast_derived(), src.derived(), internal::div_assign_op<Scalar,typename SrcXprType::Scalar>());
  78   }
  79
  80   template<typename DstXprType, typename SrcXprType>
  81   void swap_using_evaluator(const DstXprType& dst, const SrcXprType& src)
  82   {
  83     typedef typename DstXprType::Scalar Scalar;
  84     call_assignment(dst.const_cast_derived(), src.const_cast_derived(), internal::swap_assign_op<Scalar>());
  85   }
  86
  87   namespace internal {
  88     template<typename Dst, template <typename> class StorageBase, typename Src, typename Func>
  89     EIGEN_DEVICE_FUNC void call_assignment(const NoAlias<Dst,StorageBase>& dst, const Src& src, const Func& func)
  90     {
  91       call_assignment_no_alias(dst.expression(), src, func);
  92     }
  93   }
  94
  95 }
  96
  97 template<typename XprType> long get_cost(const XprType& ) { return Eigen::internal::evaluator<XprType>::CoeffReadCost; }
  98
  99 using namespace std;
 100
 101 #define VERIFY_IS_APPROX_EVALUATOR(DEST,EXPR) VERIFY_IS_APPROX(copy_using_evaluator(DEST,(EXPR)), (EXPR).eval());
 102 #define VERIFY_IS_APPROX_EVALUATOR2(DEST,EXPR,REF) VERIFY_IS_APPROX(copy_using_evaluator(DEST,(EXPR)), (REF).eval());
 103
 104 void test_evaluators()
 105 {
 106   // Testing Matrix evaluator and Transpose
 107   Vector2d v = Vector2d::Random();
 108   const Vector2d v_const(v);
 109   Vector2d v2;
 110   RowVector2d w;
 111
 112   VERIFY_IS_APPROX_EVALUATOR(v2, v);
 113   VERIFY_IS_APPROX_EVALUATOR(v2, v_const);
 114
 115   // Testing Transpose
 116   VERIFY_IS_APPROX_EVALUATOR(w, v.transpose()); // Transpose as rvalue
 117   VERIFY_IS_APPROX_EVALUATOR(w, v_const.transpose());
 118
 119   copy_using_evaluator(w.transpose(), v); // Transpose as lvalue
 120   VERIFY_IS_APPROX(w,v.transpose().eval());
 121
 122   copy_using_evaluator(w.transpose(), v_const);
 123   VERIFY_IS_APPROX(w,v_const.transpose().eval());
 124
 125   // Testing Array evaluator
 126   {
 127     ArrayXXf a(2,3);
 128     ArrayXXf b(3,2);
 129     a << 1,2,3, 4,5,6;
 130     const ArrayXXf a_const(a);
 131
 132     VERIFY_IS_APPROX_EVALUATOR(b, a.transpose());
 133
 134     VERIFY_IS_APPROX_EVALUATOR(b, a_const.transpose());
 135
 136     // Testing CwiseNullaryOp evaluator
 137     copy_using_evaluator(w, RowVector2d::Random());
 138     VERIFY((w.array() >= -1).all() && (w.array() <= 1).all()); // not easy to test ...
 139
 140     VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Zero());
 141
 142     VERIFY_IS_APPROX_EVALUATOR(w, RowVector2d::Constant(3));
 143
 144     // mix CwiseNullaryOp and transpose
 145     VERIFY_IS_APPROX_EVALUATOR(w, Vector2d::Zero().transpose());
 146   }
 147
 148   {
 149     // test product expressions
 150     int s = internal::random<int>(1,100);
 151     MatrixXf a(s,s), b(s,s), c(s,s), d(s,s);
 152     a.setRandom();
 153     b.setRandom();
 154     c.setRandom();
 155     d.setRandom();
 156     VERIFY_IS_APPROX_EVALUATOR(d, (a + b));
 157     VERIFY_IS_APPROX_EVALUATOR(d, (a + b).transpose());
 158     VERIFY_IS_APPROX_EVALUATOR2(d, prod(a,b), a*b);
 159     VERIFY_IS_APPROX_EVALUATOR2(d.noalias(), prod(a,b), a*b);
 160     VERIFY_IS_APPROX_EVALUATOR2(d, prod(a,b) + c, a*b + c);
 161     VERIFY_IS_APPROX_EVALUATOR2(d, s * prod(a,b), s * a*b);
 162     VERIFY_IS_APPROX_EVALUATOR2(d, prod(a,b).transpose(), (a*b).transpose());
 163     VERIFY_IS_APPROX_EVALUATOR2(d, prod(a,b) + prod(b,c), a*b + b*c);
 164
 165     // check that prod works even with aliasing present
 166     c = a*a;
 167     copy_using_evaluator(a, prod(a,a));
 168     VERIFY_IS_APPROX(a,c);
 169
 170     // check compound assignment of products
 171     d = c;
 172     add_assign_using_evaluator(c.noalias(), prod(a,b));
 173     d.noalias() += a*b;
 174     VERIFY_IS_APPROX(c, d);
 175
 176     d = c;
 177     subtract_assign_using_evaluator(c.noalias(), prod(a,b));
 178     d.noalias() -= a*b;
 179     VERIFY_IS_APPROX(c, d);
 180   }
 181
 182   {
 183     // test product with all possible sizes
 184     int s = internal::random<int>(1,100);
 185     Matrix<float,      1,      1> m11, res11;  m11.setRandom(1,1);
 186     Matrix<float,      1,      4> m14, res14;  m14.setRandom(1,4);
 187     Matrix<float,      1,Dynamic> m1X, res1X;  m1X.setRandom(1,s);
 188     Matrix<float,      4,      1> m41, res41;  m41.setRandom(4,1);
 189     Matrix<float,      4,      4> m44, res44;  m44.setRandom(4,4);
 190     Matrix<float,      4,Dynamic> m4X, res4X;  m4X.setRandom(4,s);
 191     Matrix<float,Dynamic,      1> mX1, resX1;  mX1.setRandom(s,1);
 192     Matrix<float,Dynamic,      4> mX4, resX4;  mX4.setRandom(s,4);
 193     Matrix<float,Dynamic,Dynamic> mXX, resXX;  mXX.setRandom(s,s);
 194
 195     VERIFY_IS_APPROX_EVALUATOR2(res11, prod(m11,m11), m11*m11);
 196     VERIFY_IS_APPROX_EVALUATOR2(res11, prod(m14,m41), m14*m41);
 197     VERIFY_IS_APPROX_EVALUATOR2(res11, prod(m1X,mX1), m1X*mX1);
 198     VERIFY_IS_APPROX_EVALUATOR2(res14, prod(m11,m14), m11*m14);
 199     VERIFY_IS_APPROX_EVALUATOR2(res14, prod(m14,m44), m14*m44);
 200     VERIFY_IS_APPROX_EVALUATOR2(res14, prod(m1X,mX4), m1X*mX4);
 201     VERIFY_IS_APPROX_EVALUATOR2(res1X, prod(m11,m1X), m11*m1X);
 202     VERIFY_IS_APPROX_EVALUATOR2(res1X, prod(m14,m4X), m14*m4X);
 203     VERIFY_IS_APPROX_EVALUATOR2(res1X, prod(m1X,mXX), m1X*mXX);
 204     VERIFY_IS_APPROX_EVALUATOR2(res41, prod(m41,m11), m41*m11);
 205     VERIFY_IS_APPROX_EVALUATOR2(res41, prod(m44,m41), m44*m41);
 206     VERIFY_IS_APPROX_EVALUATOR2(res41, prod(m4X,mX1), m4X*mX1);
 207     VERIFY_IS_APPROX_EVALUATOR2(res44, prod(m41,m14), m41*m14);
 208     VERIFY_IS_APPROX_EVALUATOR2(res44, prod(m44,m44), m44*m44);
 209     VERIFY_IS_APPROX_EVALUATOR2(res44, prod(m4X,mX4), m4X*mX4);
 210     VERIFY_IS_APPROX_EVALUATOR2(res4X, prod(m41,m1X), m41*m1X);
 211     VERIFY_IS_APPROX_EVALUATOR2(res4X, prod(m44,m4X), m44*m4X);
 212     VERIFY_IS_APPROX_EVALUATOR2(res4X, prod(m4X,mXX), m4X*mXX);
 213     VERIFY_IS_APPROX_EVALUATOR2(resX1, prod(mX1,m11), mX1*m11);
 214     VERIFY_IS_APPROX_EVALUATOR2(resX1, prod(mX4,m41), mX4*m41);
 215     VERIFY_IS_APPROX_EVALUATOR2(resX1, prod(mXX,mX1), mXX*mX1);
 216     VERIFY_IS_APPROX_EVALUATOR2(resX4, prod(mX1,m14), mX1*m14);
 217     VERIFY_IS_APPROX_EVALUATOR2(resX4, prod(mX4,m44), mX4*m44);
 218     VERIFY_IS_APPROX_EVALUATOR2(resX4, prod(mXX,mX4), mXX*mX4);
 219     VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mX1,m1X), mX1*m1X);
 220     VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mX4,m4X), mX4*m4X);
 221     VERIFY_IS_APPROX_EVALUATOR2(resXX, prod(mXX,mXX), mXX*mXX);
 222   }
 223
 224   {
 225     ArrayXXf a(2,3);
 226     ArrayXXf b(3,2);
 227     a << 1,2,3, 4,5,6;
 228     const ArrayXXf a_const(a);
 229
 230     // this does not work because Random is eval-before-nested:
 231     // copy_using_evaluator(w, Vector2d::Random().transpose());
 232
 233     // test CwiseUnaryOp
 234     VERIFY_IS_APPROX_EVALUATOR(v2, 3 * v);
 235     VERIFY_IS_APPROX_EVALUATOR(w, (3 * v).transpose());
 236     VERIFY_IS_APPROX_EVALUATOR(b, (a + 3).transpose());
 237     VERIFY_IS_APPROX_EVALUATOR(b, (2 * a_const + 3).transpose());
 238
 239     // test CwiseBinaryOp
 240     VERIFY_IS_APPROX_EVALUATOR(v2, v + Vector2d::Ones());
 241     VERIFY_IS_APPROX_EVALUATOR(w, (v + Vector2d::Ones()).transpose().cwiseProduct(RowVector2d::Constant(3)));
 242
 243     // dynamic matrices and arrays
 244     MatrixXd mat1(6,6), mat2(6,6);
 245     VERIFY_IS_APPROX_EVALUATOR(mat1, MatrixXd::Identity(6,6));
 246     VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
 247     copy_using_evaluator(mat2.transpose(), mat1);
 248     VERIFY_IS_APPROX(mat2.transpose(), mat1);
 249
 250     ArrayXXd arr1(6,6), arr2(6,6);
 251     VERIFY_IS_APPROX_EVALUATOR(arr1, ArrayXXd::Constant(6,6, 3.0));
 252     VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
 253
 254     // test automatic resizing
 255     mat2.resize(3,3);
 256     VERIFY_IS_APPROX_EVALUATOR(mat2, mat1);
 257     arr2.resize(9,9);
 258     VERIFY_IS_APPROX_EVALUATOR(arr2, arr1);
 259
 260     // test direct traversal
 261     Matrix3f m3;
 262     Array33f a3;
 263     VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity());  // matrix, nullary
 264     // TODO: find a way to test direct traversal with array
 265     VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Identity().transpose());  // transpose
 266     VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Identity());  // unary
 267     VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Identity() + Matrix3f::Zero());  // binary
 268     VERIFY_IS_APPROX_EVALUATOR(m3.block(0,0,2,2), Matrix3f::Identity().block(1,1,2,2));  // block
 269
 270     // test linear traversal
 271     VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero());  // matrix, nullary
 272     VERIFY_IS_APPROX_EVALUATOR(a3, Array33f::Zero());  // array
 273     VERIFY_IS_APPROX_EVALUATOR(m3.transpose(), Matrix3f::Zero().transpose());  // transpose
 274     VERIFY_IS_APPROX_EVALUATOR(m3, 2 * Matrix3f::Zero());  // unary
 275     VERIFY_IS_APPROX_EVALUATOR(m3, Matrix3f::Zero() + m3);  // binary
 276
 277     // test inner vectorization
 278     Matrix4f m4, m4src = Matrix4f::Random();
 279     Array44f a4, a4src = Matrix4f::Random();
 280     VERIFY_IS_APPROX_EVALUATOR(m4, m4src);  // matrix
 281     VERIFY_IS_APPROX_EVALUATOR(a4, a4src);  // array
 282     VERIFY_IS_APPROX_EVALUATOR(m4.transpose(), m4src.transpose());  // transpose
 283     // TODO: find out why Matrix4f::Zero() does not allow inner vectorization
 284     VERIFY_IS_APPROX_EVALUATOR(m4, 2 * m4src);  // unary
 285     VERIFY_IS_APPROX_EVALUATOR(m4, m4src + m4src);  // binary
 286
 287     // test linear vectorization
 288     MatrixXf mX(6,6), mXsrc = MatrixXf::Random(6,6);
 289     ArrayXXf aX(6,6), aXsrc = ArrayXXf::Random(6,6);
 290     VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc);  // matrix
 291     VERIFY_IS_APPROX_EVALUATOR(aX, aXsrc);  // array
 292     VERIFY_IS_APPROX_EVALUATOR(mX.transpose(), mXsrc.transpose());  // transpose
 293     VERIFY_IS_APPROX_EVALUATOR(mX, MatrixXf::Zero(6,6));  // nullary
 294     VERIFY_IS_APPROX_EVALUATOR(mX, 2 * mXsrc);  // unary
 295     VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc + mXsrc);  // binary
 296
 297     // test blocks and slice vectorization
 298     VERIFY_IS_APPROX_EVALUATOR(m4, (mXsrc.block<4,4>(1,0)));
 299     VERIFY_IS_APPROX_EVALUATOR(aX, ArrayXXf::Constant(10, 10, 3.0).block(2, 3, 6, 6));
 300
 301     Matrix4f m4ref = m4;
 302     copy_using_evaluator(m4.block(1, 1, 2, 3), m3.bottomRows(2));
 303     m4ref.block(1, 1, 2, 3) = m3.bottomRows(2);
 304     VERIFY_IS_APPROX(m4, m4ref);
 305
 306     mX.setIdentity(20,20);
 307     MatrixXf mXref = MatrixXf::Identity(20,20);
 308     mXsrc = MatrixXf::Random(9,12);
 309     copy_using_evaluator(mX.block(4, 4, 9, 12), mXsrc);
 310     mXref.block(4, 4, 9, 12) = mXsrc;
 311     VERIFY_IS_APPROX(mX, mXref);
 312
 313     // test Map
 314     const float raw[3] = {1,2,3};
 315     float buffer[3] = {0,0,0};
 316     Vector3f v3;
 317     Array3f a3f;
 318     VERIFY_IS_APPROX_EVALUATOR(v3, Map<const Vector3f>(raw));
 319     VERIFY_IS_APPROX_EVALUATOR(a3f, Map<const Array3f>(raw));
 320     Vector3f::Map(buffer) = 2*v3;
 321     VERIFY(buffer[0] == 2);
 322     VERIFY(buffer[1] == 4);
 323     VERIFY(buffer[2] == 6);
 324
 325     // test CwiseUnaryView
 326     mat1.setRandom();
 327     mat2.setIdentity();
 328     MatrixXcd matXcd(6,6), matXcd_ref(6,6);
 329     copy_using_evaluator(matXcd.real(), mat1);
 330     copy_using_evaluator(matXcd.imag(), mat2);
 331     matXcd_ref.real() = mat1;
 332     matXcd_ref.imag() = mat2;
 333     VERIFY_IS_APPROX(matXcd, matXcd_ref);
 334
 335     // test Select
 336     VERIFY_IS_APPROX_EVALUATOR(aX, (aXsrc > 0).select(aXsrc, -aXsrc));
 337
 338     // test Replicate
 339     mXsrc = MatrixXf::Random(6, 6);
 340     VectorXf vX = VectorXf::Random(6);
 341     mX.resize(6, 6);
 342     VERIFY_IS_APPROX_EVALUATOR(mX, mXsrc.colwise() + vX);
 343     matXcd.resize(12, 12);
 344     VERIFY_IS_APPROX_EVALUATOR(matXcd, matXcd_ref.replicate(2,2));
 345     VERIFY_IS_APPROX_EVALUATOR(matXcd, (matXcd_ref.replicate<2,2>()));
 346
 347     // test partial reductions
 348     VectorXd vec1(6);
 349     VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.rowwise().sum());
 350     VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.colwise().sum().transpose());
 351
 352     // test MatrixWrapper and ArrayWrapper
 353     mat1.setRandom(6,6);
 354     arr1.setRandom(6,6);
 355     VERIFY_IS_APPROX_EVALUATOR(mat2, arr1.matrix());
 356     VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array());
 357     VERIFY_IS_APPROX_EVALUATOR(mat2, (arr1 + 2).matrix());
 358     VERIFY_IS_APPROX_EVALUATOR(arr2, mat1.array() + 2);
 359     mat2.array() = arr1 * arr1;
 360     VERIFY_IS_APPROX(mat2, (arr1 * arr1).matrix());
 361     arr2.matrix() = MatrixXd::Identity(6,6);
 362     VERIFY_IS_APPROX(arr2, MatrixXd::Identity(6,6).array());
 363
 364     // test Reverse
 365     VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.reverse());
 366     VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.colwise().reverse());
 367     VERIFY_IS_APPROX_EVALUATOR(arr2, arr1.rowwise().reverse());
 368     arr2.reverse() = arr1;
 369     VERIFY_IS_APPROX(arr2, arr1.reverse());
 370     mat2.array() = mat1.array().reverse();
 371     VERIFY_IS_APPROX(mat2.array(), mat1.array().reverse());
 372
 373     // test Diagonal
 374     VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal());
 375     vec1.resize(5);
 376     VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal(1));
 377     VERIFY_IS_APPROX_EVALUATOR(vec1, mat1.diagonal<-1>());
 378     vec1.setRandom();
 379
 380     mat2 = mat1;
 381     copy_using_evaluator(mat1.diagonal(1), vec1);
 382     mat2.diagonal(1) = vec1;
 383     VERIFY_IS_APPROX(mat1, mat2);
 384
 385     copy_using_evaluator(mat1.diagonal<-1>(), mat1.diagonal(1));
 386     mat2.diagonal<-1>() = mat2.diagonal(1);
 387     VERIFY_IS_APPROX(mat1, mat2);
 388   }
 389
 390   {
 391     // test swapping
 392     MatrixXd mat1, mat2, mat1ref, mat2ref;
 393     mat1ref = mat1 = MatrixXd::Random(6, 6);
 394     mat2ref = mat2 = 2 * mat1 + MatrixXd::Identity(6, 6);
 395     swap_using_evaluator(mat1, mat2);
 396     mat1ref.swap(mat2ref);
 397     VERIFY_IS_APPROX(mat1, mat1ref);
 398     VERIFY_IS_APPROX(mat2, mat2ref);
 399
 400     swap_using_evaluator(mat1.block(0, 0, 3, 3), mat2.block(3, 3, 3, 3));
 401     mat1ref.block(0, 0, 3, 3).swap(mat2ref.block(3, 3, 3, 3));
 402     VERIFY_IS_APPROX(mat1, mat1ref);
 403     VERIFY_IS_APPROX(mat2, mat2ref);
 404
 405     swap_using_evaluator(mat1.row(2), mat2.col(3).transpose());
 406     mat1.row(2).swap(mat2.col(3).transpose());
 407     VERIFY_IS_APPROX(mat1, mat1ref);
 408     VERIFY_IS_APPROX(mat2, mat2ref);
 409   }
 410
 411   {
 412     // test compound assignment
 413     const Matrix4d mat_const = Matrix4d::Random();
 414     Matrix4d mat, mat_ref;
 415     mat = mat_ref = Matrix4d::Identity();
 416     add_assign_using_evaluator(mat, mat_const);
 417     mat_ref += mat_const;
 418     VERIFY_IS_APPROX(mat, mat_ref);
 419
 420     subtract_assign_using_evaluator(mat.row(1), 2*mat.row(2));
 421     mat_ref.row(1) -= 2*mat_ref.row(2);
 422     VERIFY_IS_APPROX(mat, mat_ref);
 423
 424     const ArrayXXf arr_const = ArrayXXf::Random(5,3);
 425     ArrayXXf arr, arr_ref;
 426     arr = arr_ref = ArrayXXf::Constant(5, 3, 0.5);
 427     multiply_assign_using_evaluator(arr, arr_const);
 428     arr_ref *= arr_const;
 429     VERIFY_IS_APPROX(arr, arr_ref);
 430
 431     divide_assign_using_evaluator(arr.row(1), arr.row(2) + 1);
 432     arr_ref.row(1) /= (arr_ref.row(2) + 1);
 433     VERIFY_IS_APPROX(arr, arr_ref);
 434   }
 435
 436   {
 437     // test triangular shapes
 438     MatrixXd A = MatrixXd::Random(6,6), B(6,6), C(6,6), D(6,6);
 439     A.setRandom();B.setRandom();
 440     VERIFY_IS_APPROX_EVALUATOR2(B, A.triangularView<Upper>(), MatrixXd(A.triangularView<Upper>()));
 441
 442     A.setRandom();B.setRandom();
 443     VERIFY_IS_APPROX_EVALUATOR2(B, A.triangularView<UnitLower>(), MatrixXd(A.triangularView<UnitLower>()));
 444
 445     A.setRandom();B.setRandom();
 446     VERIFY_IS_APPROX_EVALUATOR2(B, A.triangularView<UnitUpper>(), MatrixXd(A.triangularView<UnitUpper>()));
 447
 448     A.setRandom();B.setRandom();
 449     C = B; C.triangularView<Upper>() = A;
 450     copy_using_evaluator(B.triangularView<Upper>(), A);
 451     VERIFY(B.isApprox(C) && "copy_using_evaluator(B.triangularView<Upper>(), A)");
 452
 453     A.setRandom();B.setRandom();
 454     C = B; C.triangularView<Lower>() = A.triangularView<Lower>();
 455     copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Lower>());
 456     VERIFY(B.isApprox(C) && "copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Lower>())");
 457
 458
 459     A.setRandom();B.setRandom();
 460     C = B; C.triangularView<Lower>() = A.triangularView<Upper>().transpose();
 461     copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Upper>().transpose());
 462     VERIFY(B.isApprox(C) && "copy_using_evaluator(B.triangularView<Lower>(), A.triangularView<Lower>().transpose())");
 463
 464
 465     A.setRandom();B.setRandom(); C = B; D = A;
 466     C.triangularView<Upper>().swap(D.triangularView<Upper>());
 467     swap_using_evaluator(B.triangularView<Upper>(), A.triangularView<Upper>());
 468     VERIFY(B.isApprox(C) && "swap_using_evaluator(B.triangularView<Upper>(), A.triangularView<Upper>())");
 469
 470
 471     VERIFY_IS_APPROX_EVALUATOR2(B, prod(A.triangularView<Upper>(),A), MatrixXd(A.triangularView<Upper>()*A));
 472
 473     VERIFY_IS_APPROX_EVALUATOR2(B, prod(A.selfadjointView<Upper>(),A), MatrixXd(A.selfadjointView<Upper>()*A));
 474   }
 475
 476   {
 477     // test diagonal shapes
 478     VectorXd d = VectorXd::Random(6);
 479     MatrixXd A = MatrixXd::Random(6,6), B(6,6);
 480     A.setRandom();B.setRandom();
 481
 482     VERIFY_IS_APPROX_EVALUATOR2(B, lazyprod(d.asDiagonal(),A), MatrixXd(d.asDiagonal()*A));
 483     VERIFY_IS_APPROX_EVALUATOR2(B, lazyprod(A,d.asDiagonal()), MatrixXd(A*d.asDiagonal()));
 484   }
 485
 486   {
 487     // test CoeffReadCost
 488     Matrix4d a, b;
 489     VERIFY_IS_EQUAL( get_cost(a), 1 );
 490     VERIFY_IS_EQUAL( get_cost(a+b), 3);
 491     VERIFY_IS_EQUAL( get_cost(2*a+b), 4);
 492     VERIFY_IS_EQUAL( get_cost(a*b), 1);
 493     VERIFY_IS_EQUAL( get_cost(a.lazyProduct(b)), 15);
 494     VERIFY_IS_EQUAL( get_cost(a*(a*b)), 1);
 495     VERIFY_IS_EQUAL( get_cost(a.lazyProduct(a*b)), 15);
 496     VERIFY_IS_EQUAL( get_cost(a*(a+b)), 1);
 497     VERIFY_IS_EQUAL( get_cost(a.lazyProduct(a+b)), 15);
 498   }
 499 }