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

- eigen2 now fully enforces constness! found a way to achieve that

Browse Source 
with minimal code duplication. There now are only two (2)
  const_cast remaining in the whole source code.
- eigen2 now fully allows copying a row-vector into a column-vector.
  added a unit-test for that.
- split unit tests, improve docs, various improvements.
This commit is contained in:
Benoit Jacob
2007-12-25 17:20:58 +00:00
parent 3cd2a125b2
commit dad245af56
26 changed files with 414 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
test/basicstuff.cpp
View File

@@ -29,18 +29,9 @@ namespace Eigen {
template<typename MatrixType> void basicStuff(const MatrixType& m)
{
/* this test covers the following files:
1) Explicitly (see comments below):
Random.h Zero.h Identity.h Fuzzy.h Sum.h Difference.h
Opposite.h Product.h ScalarMultiple.h Map.h
2) Implicitly (the core stuff):
MatrixBase.h Matrix.h MatrixStorage.h CopyHelper.h MatrixRef.h
NumTraits.h Util.h MathFunctions.h OperatorEquals.h Coeffs.h
*/
typedef typename MatrixType::Scalar Scalar;
typedef Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> VectorType;
int rows = m.rows();
int cols = m.cols();
@@ -58,13 +49,9 @@ template<typename MatrixType> void basicStuff(const MatrixType& m)
v2 = VectorType::random(rows),
vzero = VectorType::zero(rows);
Scalar s1 = random<Scalar>(),
s2 = random<Scalar>();
int r = random<int>(0, rows-1),
c = random<int>(0, cols-1);
// test Fuzzy.h and Zero.h.
VERIFY_IS_APPROX( v1, v1);
VERIFY_IS_NOT_APPROX( v1, 2*v1);
VERIFY_IS_MUCH_SMALLER_THAN( vzero, v1);
@@ -86,80 +73,13 @@ template<typename MatrixType> void basicStuff(const MatrixType& m)
// operator() that gets called, which in turn calls _read().
VERIFY_IS_MUCH_SMALLER_THAN(MatrixType::zero(rows,cols)(r,c), static_cast<Scalar>(1));
// test the linear structure, i.e. the following files:
// Sum.h Difference.h Opposite.h ScalarMultiple.h
VERIFY_IS_APPROX(-(-m1), m1);
VERIFY_IS_APPROX(m1+m1, 2*m1);
VERIFY_IS_APPROX(m1+m2-m1, m2);
VERIFY_IS_APPROX(-m2+m1+m2, m1);
VERIFY_IS_APPROX(m1*s1, s1*m1);
VERIFY_IS_APPROX((m1+m2)*s1, s1*m1+s1*m2);
VERIFY_IS_APPROX((s1+s2)*m1, m1*s1+m1*s2);
VERIFY_IS_APPROX((m1-m2)*s1, s1*m1-s1*m2);
VERIFY_IS_APPROX((s1-s2)*m1, m1*s1-m1*s2);
VERIFY_IS_APPROX((-m1+m2)*s1, -s1*m1+s1*m2);
VERIFY_IS_APPROX((-s1+s2)*m1, -m1*s1+m1*s2);
m3 = m2; m3 += m1;
VERIFY_IS_APPROX(m3, m1+m2);
m3 = m2; m3 -= m1;
VERIFY_IS_APPROX(m3, m2-m1);
m3 = m2; m3 *= s1;
VERIFY_IS_APPROX(m3, s1*m2);
if(NumTraits<Scalar>::HasFloatingPoint)
{
m3 = m2; m3 /= s1;
VERIFY_IS_APPROX(m3, m2/s1);
}
// again, test operator() to check const-qualification
VERIFY_IS_APPROX((-m1)(r,c), -(m1(r,c)));
VERIFY_IS_APPROX((m1-m2)(r,c), (m1(r,c))-(m2(r,c)));
VERIFY_IS_APPROX((m1+m2)(r,c), (m1(r,c))+(m2(r,c)));
VERIFY_IS_APPROX((s1*m1)(r,c), s1*(m1(r,c)));
VERIFY_IS_APPROX((m1*s1)(r,c), (m1(r,c))*s1);
if(NumTraits<Scalar>::HasFloatingPoint)
VERIFY_IS_APPROX((m1/s1)(r,c), (m1(r,c))/s1);
// begin testing Product.h: only associativity for now
// (we use Transpose.h but this doesn't count as a test for it)
VERIFY_IS_APPROX((m1*m1.transpose())*m2, m1*(m1.transpose()*m2));
m3 = m1;
m3 *= (m1.transpose() * m2);
VERIFY_IS_APPROX(m3, m1*(m1.transpose()*m2));
VERIFY_IS_APPROX(m3, m1.lazyProduct(m1.transpose()*m2));
// continue testing Product.h: distributivity
VERIFY_IS_APPROX(square*(m1 + m2), square*m1+square*m2);
VERIFY_IS_APPROX(square*(m1 - m2), square*m1-square*m2);
// continue testing Product.h: compatibility with ScalarMultiple.h
VERIFY_IS_APPROX(s1*(square*m1), (s1*square)*m1);
VERIFY_IS_APPROX(s1*(square*m1), square*(m1*s1));
// continue testing Product.h: lazyProduct
VERIFY_IS_APPROX(square.lazyProduct(m1), square*m1);
// again, test operator() to check const-qualification
s1 += square.lazyProduct(m1)(r,c);
// test Product.h together with Identity.h
VERIFY_IS_APPROX(m1, identity*m1);
VERIFY_IS_APPROX(v1, identity*v1);
// again, test operator() to check const-qualification
VERIFY_IS_APPROX(MatrixType::identity(std::max(rows,cols))(r,c), static_cast<Scalar>(r==c));
// test Map.h
Scalar* array1 = new Scalar[rows];
Scalar* array2 = new Scalar[rows];
typedef Matrix<Scalar, Dynamic, 1> VectorX;
VectorX::map(array1, rows) = VectorX::random(rows);
VectorX::map(array2, rows) = VectorX::map(array1, rows);
VectorX ma1 = VectorX::map(array1, rows);
VectorX ma2 = VectorX::map(array2, rows);
VERIFY_IS_APPROX(ma1, ma2);
VERIFY_IS_APPROX(ma1, VectorX(array2, rows));
delete[] array1;
delete[] array2;
// now test copying a row-vector into a (column-)vector and conversely.
square.col(r) = square.row(r).eval();
Matrix<Scalar, 1, MatrixType::RowsAtCompileTime> rv(rows);
Matrix<Scalar, MatrixType::RowsAtCompileTime, 1> cv(rows);
rv = square.col(r);
cv = square.row(r);
VERIFY_IS_APPROX(rv, cv.transpose());
}
void EigenTest::testBasicStuff()