GitHub-Proxy/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2025-04-22 01:29:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

update mixingtype unit test to reflect current status, but it is still clear

Browse Source 
we should allow matrix products between complex and real ?
This commit is contained in:
Gael Guennebaud 2009-09-03 13:03:26 +02:00
parent 00f4b46908
commit 3eb37fe1fb
3 changed files with 97 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
Eigen/src/Core/Product.h
View File

@ -162,7 +162,11 @@ class GeneralProduct<Lhs, Rhs, InnerProduct>
public: public:
EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct) EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct)
GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) {} GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs)
{
EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret),
YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
}
EIGEN_STRONG_INLINE Scalar value() const EIGEN_STRONG_INLINE Scalar value() const
{ {
@ -197,7 +201,11 @@ class GeneralProduct<Lhs, Rhs, OuterProduct>
public: public:
EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct) EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct)
GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) {} GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs)
{
EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret),
YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
}
template<typename Dest> void scaleAndAddTo(Dest& dest, Scalar alpha) const template<typename Dest> void scaleAndAddTo(Dest& dest, Scalar alpha) const
{ {
@ -251,7 +259,11 @@ class GeneralProduct<Lhs, Rhs, GemvProduct>
public: public:
EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct) EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct)
GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) {} GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs)
{
EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret),
YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
}
enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight }; enum { Side = Lhs::IsVectorAtCompileTime ? OnTheLeft : OnTheRight };
typedef typename ei_meta_if<int(Side)==OnTheRight,_LhsNested,_RhsNested>::ret MatrixType; typedef typename ei_meta_if<int(Side)==OnTheRight,_LhsNested,_RhsNested>::ret MatrixType;

6
Eigen/src/Core/products/GeneralMatrixMatrix.h
View File

@ -135,7 +135,11 @@ class GeneralProduct<Lhs, Rhs, GemmProduct>
public: public:
EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct) EIGEN_PRODUCT_PUBLIC_INTERFACE(GeneralProduct)
GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs) {} GeneralProduct(const Lhs& lhs, const Rhs& rhs) : Base(lhs,rhs)
{
EIGEN_STATIC_ASSERT((ei_is_same_type<typename Lhs::Scalar, typename Rhs::Scalar>::ret),
YOU_MIXED_DIFFERENT_NUMERIC_TYPES__YOU_NEED_TO_USE_THE_CAST_METHOD_OF_MATRIXBASE_TO_CAST_NUMERIC_TYPES_EXPLICITLY)
}
template<typename Dest> void scaleAndAddTo(Dest& dst, Scalar alpha) const template<typename Dest> void scaleAndAddTo(Dest& dst, Scalar alpha) const
{ {

87
test/mixingtypes.cpp
View File

@ -61,7 +61,75 @@ template<int SizeAtCompileType> void mixingtypes(int size = SizeAtCompileType)
VERIFY_RAISES_ASSERT(vf+=vd); VERIFY_RAISES_ASSERT(vf+=vd);
VERIFY_RAISES_ASSERT(mcd=md); VERIFY_RAISES_ASSERT(mcd=md);
vf.dot(vf);
VERIFY_RAISES_ASSERT(vd.dot(vf));
VERIFY_RAISES_ASSERT(vcf.dot(vf)); // yeah eventually we should allow this but i'm too lazy to make that change now in Dot.h
} // especially as that might be rewritten as cwise product .sum() which would make that automatic.
void mixingtypes_large(int size)
{
static const int SizeAtCompileType = Dynamic;
typedef Matrix<float, SizeAtCompileType, SizeAtCompileType> Mat_f;
typedef Matrix<double, SizeAtCompileType, SizeAtCompileType> Mat_d;
typedef Matrix<std::complex<float>, SizeAtCompileType, SizeAtCompileType> Mat_cf;
typedef Matrix<std::complex<double>, SizeAtCompileType, SizeAtCompileType> Mat_cd;
typedef Matrix<float, SizeAtCompileType, 1> Vec_f;
typedef Matrix<double, SizeAtCompileType, 1> Vec_d;
typedef Matrix<std::complex<float>, SizeAtCompileType, 1> Vec_cf;
typedef Matrix<std::complex<double>, SizeAtCompileType, 1> Vec_cd;
Mat_f mf(size,size);
Mat_d md(size,size);
Mat_cf mcf(size,size);
Mat_cd mcd(size,size);
Vec_f vf(size,1);
Vec_d vd(size,1);
Vec_cf vcf(size,1);
Vec_cd vcd(size,1);
mf*mf; mf*mf;
// FIXME large products does not allow mixing types
VERIFY_RAISES_ASSERT(md*mcd);
VERIFY_RAISES_ASSERT(mcd*md);
VERIFY_RAISES_ASSERT(mf*vcf);
VERIFY_RAISES_ASSERT(mcf*vf);
VERIFY_RAISES_ASSERT(mcf *= mf);
// VERIFY_RAISES_ASSERT(vcd = md*vcd); // does not even compile
VERIFY_RAISES_ASSERT(vcf = mcf*vf);
VERIFY_RAISES_ASSERT(mf*md);
VERIFY_RAISES_ASSERT(mcf*mcd);
VERIFY_RAISES_ASSERT(mcf*vcd);
VERIFY_RAISES_ASSERT(vcf = mf*vf);
}
template<int SizeAtCompileType> void mixingtypes_small()
{
int size = SizeAtCompileType;
typedef Matrix<float, SizeAtCompileType, SizeAtCompileType> Mat_f;
typedef Matrix<double, SizeAtCompileType, SizeAtCompileType> Mat_d;
typedef Matrix<std::complex<float>, SizeAtCompileType, SizeAtCompileType> Mat_cf;
typedef Matrix<std::complex<double>, SizeAtCompileType, SizeAtCompileType> Mat_cd;
typedef Matrix<float, SizeAtCompileType, 1> Vec_f;
typedef Matrix<double, SizeAtCompileType, 1> Vec_d;
typedef Matrix<std::complex<float>, SizeAtCompileType, 1> Vec_cf;
typedef Matrix<std::complex<double>, SizeAtCompileType, 1> Vec_cd;
Mat_f mf(size,size);
Mat_d md(size,size);
Mat_cf mcf(size,size);
Mat_cd mcd(size,size);
Vec_f vf(size,1);
Vec_d vd(size,1);
Vec_cf vcf(size,1);
Vec_cd vcd(size,1);
mf*mf;
// FIXME shall we discard those products ?
// 1) currently they work only if SizeAtCompileType is small enough
// 2) in case we vectorize complexes this might be difficult to still allow that
md*mcd; md*mcd;
mcd*md; mcd*md;
mf*vcf; mf*vcf;
@ -69,20 +137,19 @@ template<int SizeAtCompileType> void mixingtypes(int size = SizeAtCompileType)
mcf *= mf; mcf *= mf;
vcd = md*vcd; vcd = md*vcd;
vcf = mcf*vf; vcf = mcf*vf;
VERIFY_RAISES_ASSERT(mf*md); // VERIFY_RAISES_ASSERT(mf*md); // does not even compile
VERIFY_RAISES_ASSERT(mcf*mcd); // VERIFY_RAISES_ASSERT(mcf*mcd); // does not even compile
VERIFY_RAISES_ASSERT(mcf*vcd); // VERIFY_RAISES_ASSERT(mcf*vcd); // does not even compile
VERIFY_RAISES_ASSERT(vcf = mf*vf); VERIFY_RAISES_ASSERT(vcf = mf*vf);
}
vf.dot(vf);
VERIFY_RAISES_ASSERT(vd.dot(vf));
VERIFY_RAISES_ASSERT(vcf.dot(vf)); // yeah eventually we should allow this but i'm too lazy to make that change now in Dot.h
} // especially as that might be rewritten as cwise product .sum() which would make that automatic.
void test_mixingtypes() void test_mixingtypes()
{ {
// check that our operator new is indeed called: // check that our operator new is indeed called:
CALL_SUBTEST(mixingtypes<3>(3)); CALL_SUBTEST(mixingtypes<3>());
CALL_SUBTEST(mixingtypes<4>(4)); CALL_SUBTEST(mixingtypes<4>());
CALL_SUBTEST(mixingtypes<Dynamic>(20)); CALL_SUBTEST(mixingtypes<Dynamic>(20));
CALL_SUBTEST(mixingtypes_small<4>());
CALL_SUBTEST(mixingtypes_large(20));
} }