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

a lot of cleaning and fixes

Browse Source
This commit is contained in:
Gael Guennebaud
2009-12-16 19:18:40 +01:00
parent 22a6ab1f4b
commit 9f79558839
20 changed files with 258 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

60
test/array.cpp
View File

@@ -22,7 +22,6 @@
// License and a copy of the GNU General Public License along with
// Eigen. If not, see <http://www.gnu.org/licenses/>.
#define EIGEN2_SUPPORT
#include "main.h"
#include <Eigen/Array>
@@ -51,15 +50,15 @@ template<typename MatrixType> void array(const MatrixType& m)
s2 = ei_random<Scalar>();
// scalar addition
VERIFY_IS_APPROX(m1.cwise() + s1, s1 + m1.cwise());
VERIFY_IS_APPROX(m1.cwise() + s1, MatrixType::Constant(rows,cols,s1) + m1);
VERIFY_IS_APPROX((m1*Scalar(2)).cwise() - s2, (m1+m1) - MatrixType::Constant(rows,cols,s2) );
VERIFY_IS_APPROX(m1.array() + s1, s1 + m1.array());
VERIFY_IS_APPROX((m1.array() + s1).asMatrix(), MatrixType::Constant(rows,cols,s1) + m1);
VERIFY_IS_APPROX(((m1*Scalar(2)).array() - s2).asMatrix(), (m1+m1) - MatrixType::Constant(rows,cols,s2) );
m3 = m1;
m3.cwise() += s2;
VERIFY_IS_APPROX(m3, m1.cwise() + s2);
m3.array() += s2;
VERIFY_IS_APPROX(m3, (m1.array() + s2).asMatrix());
m3 = m1;
m3.cwise() -= s1;
VERIFY_IS_APPROX(m3, m1.cwise() - s1);
m3.array() -= s1;
VERIFY_IS_APPROX(m3, (m1.array() - s1).asMatrix());
// reductions
VERIFY_IS_APPROX(m1.colwise().sum().sum(), m1.sum());
@@ -95,53 +94,54 @@ template<typename MatrixType> void comparisons(const MatrixType& m)
m2 = MatrixType::Random(rows, cols),
m3(rows, cols);
VERIFY(((m1.cwise() + Scalar(1)).cwise() > m1).all());
VERIFY(((m1.cwise() - Scalar(1)).cwise() < m1).all());
VERIFY(((m1.array() + Scalar(1)) > m1.array()).all());
VERIFY(((m1.array() - Scalar(1)) < m1.array()).all());
if (rows*cols>1)
{
m3 = m1;
m3(r,c) += 1;
VERIFY(! (m1.cwise() < m3).all() );
VERIFY(! (m1.cwise() > m3).all() );
VERIFY(! (m1.array() < m3.array()).all() );
VERIFY(! (m1.array() > m3.array()).all() );
}
// comparisons to scalar
VERIFY( (m1.cwise() != (m1(r,c)+1) ).any() );
VERIFY( (m1.cwise() > (m1(r,c)-1) ).any() );
VERIFY( (m1.cwise() < (m1(r,c)+1) ).any() );
VERIFY( (m1.cwise() == m1(r,c) ).any() );
VERIFY( (m1.array() != (m1(r,c)+1) ).any() );
VERIFY( (m1.array() > (m1(r,c)-1) ).any() );
VERIFY( (m1.array() < (m1(r,c)+1) ).any() );
VERIFY( (m1.array() == m1(r,c) ).any() );
// test Select
VERIFY_IS_APPROX( (m1.cwise()<m2).select(m1,m2), m1.cwise().min(m2) );
VERIFY_IS_APPROX( (m1.cwise()>m2).select(m1,m2), m1.cwise().max(m2) );
Scalar mid = (m1.cwise().abs().minCoeff() + m1.cwise().abs().maxCoeff())/Scalar(2);
VERIFY_IS_APPROX( (m1.array()<m2.array()).select(m1,m2), m1.cwiseMin(m2) );
VERIFY_IS_APPROX( (m1.array()>m2.array()).select(m1,m2), m1.cwiseMax(m2) );
Scalar mid = (m1.cwiseAbs().minCoeff() + m1.cwiseAbs().maxCoeff())/Scalar(2);
for (int j=0; j<cols; ++j)
for (int i=0; i<rows; ++i)
m3(i,j) = ei_abs(m1(i,j))<mid ? 0 : m1(i,j);
VERIFY_IS_APPROX( (m1.cwise().abs().cwise()<MatrixType::Constant(rows,cols,mid))
VERIFY_IS_APPROX( (m1.array().abs()<MatrixType::Constant(rows,cols,mid).array())
.select(MatrixType::Zero(rows,cols),m1), m3);
// shorter versions:
VERIFY_IS_APPROX( (m1.cwise().abs().cwise()<MatrixType::Constant(rows,cols,mid))
VERIFY_IS_APPROX( (m1.array().abs()<MatrixType::Constant(rows,cols,mid).array())
.select(0,m1), m3);
VERIFY_IS_APPROX( (m1.cwise().abs().cwise()>=MatrixType::Constant(rows,cols,mid))
VERIFY_IS_APPROX( (m1.array().abs()>=MatrixType::Constant(rows,cols,mid).array())
.select(m1,0), m3);
// even shorter version:
VERIFY_IS_APPROX( (m1.cwise().abs().cwise()<mid).select(0,m1), m3);
VERIFY_IS_APPROX( (m1.array().abs()<mid).select(0,m1), m3);
// count
VERIFY(((m1.cwise().abs().cwise()+1).cwise()>RealScalar(0.1)).count() == rows*cols);
VERIFY_IS_APPROX(((m1.cwise().abs().cwise()+1).cwise()>RealScalar(0.1)).colwise().count(), RowVectorXi::Constant(cols,rows));
VERIFY_IS_APPROX(((m1.cwise().abs().cwise()+1).cwise()>RealScalar(0.1)).rowwise().count(), VectorXi::Constant(rows, cols));
VERIFY(((m1.array().abs()+1)>RealScalar(0.1)).count() == rows*cols);
// TODO allows colwise/rowwise for array
VERIFY_IS_APPROX(((m1.array().abs()+1)>RealScalar(0.1)).asMatrix().colwise().count(), RowVectorXi::Constant(cols,rows));
VERIFY_IS_APPROX(((m1.array().abs()+1)>RealScalar(0.1)).asMatrix().rowwise().count(), VectorXi::Constant(rows, cols));
}
template<typename VectorType> void lpNorm(const VectorType& v)
{
VectorType u = VectorType::Random(v.size());
VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), u.cwise().abs().maxCoeff());
VERIFY_IS_APPROX(u.template lpNorm<1>(), u.cwise().abs().sum());
VERIFY_IS_APPROX(u.template lpNorm<2>(), ei_sqrt(u.cwise().abs().cwise().square().sum()));
VERIFY_IS_APPROX(ei_pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.cwise().abs().cwise().pow(5).sum());
VERIFY_IS_APPROX(u.template lpNorm<Infinity>(), u.cwiseAbs().maxCoeff());
VERIFY_IS_APPROX(u.template lpNorm<1>(), u.cwiseAbs().sum());
VERIFY_IS_APPROX(u.template lpNorm<2>(), ei_sqrt(u.array().abs().square().sum()));
VERIFY_IS_APPROX(ei_pow(u.template lpNorm<5>(), typename VectorType::RealScalar(5)), u.array().abs().pow(5).sum());
}
void test_array()

46
test/linearstructure.cpp
View File

@@ -58,30 +58,30 @@ template<typename MatrixType> void linearStructure(const MatrixType& m)
VERIFY_IS_APPROX((-m1+m2)*s1, -s1*m1+s1*m2);
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);
}
// 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);
// use .block to disable vectorization and compare to the vectorized version
VERIFY_IS_APPROX(m1+m1.block(0,0,rows,cols), m1+m1);
VERIFY_IS_APPROX(m1.cwiseProduct(m1.block(0,0,rows,cols)), m1.cwiseProduct(m1));
VERIFY_IS_APPROX(m1 - m1.block(0,0,rows,cols), m1 - m1);
VERIFY_IS_APPROX(m1.block(0,0,rows,cols) * s1, m1 * 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);
//
// // use .block to disable vectorization and compare to the vectorized version
// VERIFY_IS_APPROX(m1+m1.block(0,0,rows,cols), m1+m1);
// VERIFY_IS_APPROX(m1.cwiseProduct(m1.block(0,0,rows,cols)), m1.cwiseProduct(m1));
// VERIFY_IS_APPROX(m1 - m1.block(0,0,rows,cols), m1 - m1);
// VERIFY_IS_APPROX(m1.block(0,0,rows,cols) * s1, m1 * s1);
}
void test_linearstructure()

2
test/nomalloc.cpp
View File

@@ -64,7 +64,7 @@ template<typename MatrixType> void nomalloc(const MatrixType& m)
VERIFY_IS_APPROX((m1+m2)*s1, s1*m1+s1*m2);
VERIFY_IS_APPROX((m1+m2)(r,c), (m1(r,c))+(m2(r,c)));
VERIFY_IS_APPROX(m1.cwise() * m1.block(0,0,rows,cols), m1.array()*m1);
VERIFY_IS_APPROX(m1.cwiseProduct(m1.block(0,0,rows,cols)), (m1.array()*m1.array()));
if (MatrixType::RowsAtCompileTime<EIGEN_CACHEFRIENDLY_PRODUCT_THRESHOLD) {
// If the matrices are too large, we have better to use the optimized GEMM
// routines which allocates temporaries. However, on some platforms

4
test/regression.cpp
View File

@@ -51,7 +51,7 @@ void makeNoisyCohyperplanarPoints(int numPoints,
{
cur_point = VectorType::Random(size)/*.normalized()*/;
// project cur_point onto the hyperplane
Scalar x = - (hyperplane->coeffs().start(size).cwise()*cur_point).sum();
Scalar x = - (hyperplane->coeffs().start(size).cwiseProduct(cur_point)).sum();
cur_point *= hyperplane->coeffs().coeff(size) / x;
} while( cur_point.norm() < 0.5
|| cur_point.norm() > 2.0 );
@@ -110,7 +110,7 @@ void test_regression()
CALL_SUBTEST(check_linearRegression(1000, points2f_ptrs, coeffs2f, 0.002f));
}
#endif
#ifdef EIGEN_TEST_PART_2
{
Vector2f points2f [1000];

24
test/sparse_basic.cpp
View File

@@ -64,7 +64,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
const int cols = ref.cols();
typedef typename SparseMatrixType::Scalar Scalar;
enum { Flags = SparseMatrixType::Flags };
double density = std::max(8./(rows*cols), 0.01);
typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrix;
typedef Matrix<Scalar,Dynamic,1> DenseVector;
@@ -78,7 +78,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
std::vector<Vector2i> zeroCoords;
std::vector<Vector2i> nonzeroCoords;
initSparse<Scalar>(density, refMat, m, 0, &zeroCoords, &nonzeroCoords);
if (zeroCoords.size()==0 || nonzeroCoords.size()==0)
return;
@@ -195,7 +195,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
m2.finalize();
VERIFY_IS_APPROX(m2,m1);
}
// test insert (fully random)
{
DenseMatrix m1(rows,cols);
@@ -212,7 +212,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
m2.finalize();
VERIFY_IS_APPROX(m2,m1);
}
// test RandomSetter
/*{
SparseMatrixType m1(rows,cols), m2(rows,cols);
@@ -246,20 +246,20 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
VERIFY_IS_APPROX(m1+m2, refM1+refM2);
VERIFY_IS_APPROX(m1+m2+m3, refM1+refM2+refM3);
VERIFY_IS_APPROX(m3.cwise()*(m1+m2), refM3.cwise()*(refM1+refM2));
VERIFY_IS_APPROX(m3.cwiseProduct(m1+m2), refM3.cwiseProduct(refM1+refM2));
VERIFY_IS_APPROX(m1*s1-m2, refM1*s1-refM2);
VERIFY_IS_APPROX(m1*=s1, refM1*=s1);
VERIFY_IS_APPROX(m1/=s1, refM1/=s1);
VERIFY_IS_APPROX(m1+=m2, refM1+=refM2);
VERIFY_IS_APPROX(m1-=m2, refM1-=refM2);
VERIFY_IS_APPROX(m1.col(0).dot(refM2.row(0)), refM1.col(0).dot(refM2.row(0)));
refM4.setRandom();
// sparse cwise* dense
VERIFY_IS_APPROX(m3.cwise()*refM4, refM3.cwise()*refM4);
VERIFY_IS_APPROX(m3.cwiseProduct(refM4), refM3.cwiseProduct(refM4));
// VERIFY_IS_APPROX(m3.cwise()/refM4, refM3.cwise()/refM4);
}
@@ -276,7 +276,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
//refMat2.col(j0) = 2*refMat2.col(j1);
//VERIFY_IS_APPROX(m2, refMat2);
}
// test innerVectors()
{
DenseMatrix refMat2 = DenseMatrix::Zero(rows, rows);
@@ -302,7 +302,7 @@ template<typename SparseMatrixType> void sparse_basic(const SparseMatrixType& re
VERIFY_IS_APPROX(SparseMatrixType(m2.adjoint()), refMat2.adjoint());
}
// test prune
{
SparseMatrixType m2(rows, rows);
@@ -347,7 +347,7 @@ void test_sparse_basic()
CALL_SUBTEST_1( sparse_basic(SparseMatrix<double>(8, 8)) );
CALL_SUBTEST_2( sparse_basic(SparseMatrix<std::complex<double> >(16, 16)) );
CALL_SUBTEST_1( sparse_basic(SparseMatrix<double>(33, 33)) );
CALL_SUBTEST_3( sparse_basic(DynamicSparseMatrix<double>(8, 8)) );
}
}