The implementation of type deduction of uBLAS is really complicated, sowe are still looking for a simpler version. The use of result_type ofoperator+ was already a big advantage. However the currentimplementation assumes that all operation (+,-,*,/) follow the samerules. A modification of this assumption would mean a big redesign ofmany classes. Any help is welcome.

Why is type deduction complicated? Is there some reason to not obey the rules followed by the compiler itself? You might want to look at the header operators.hpp in the proposed Boost.Units library in the Vault (mcs_units_v0.7.2.zip) - this file contains all the type deduction needed for this library, and the type operations needed for compile-time dimensional analysis have to be much more complex than those in ublas. Even if you don't have typeof support, it is possible to simply define the following helper classes specialized for the supported built-in types (if a bit tedious) :

template<typename X> struct unary_plus_typeof_helper;

template<typename X> struct unary_minus_typeof_helper;

template<typename X,typename Y> struct add_typeof_helper;

template<typename X,typename Y> struct subtract_typeof_helper;

template<typename X,typename Y> struct multiply_typeof_helper;

template<typename X,typename Y> struct divide_typeof_helper;

template<typename X,typename Y> struct power_typeof_helper;

template<typename X,typename Y> struct root_typeof_helper;

so

template<> struct add_typeof_helper<int,double> { typedef double type; }

etc... Then all operators return the appropriate type :

template<class X,class Y>

typename add_typeof_helper<X,Y>::type

operator+(const ublas<X>&,const ublas<Y>&);

Deduction in expression templates should just happen correctly if they are implemented correctly, since you should just get :

(x+y)*z -> multiply_typeof_helper< add_typeof_helper<X,Y>::type,Z>::type

I have implemented this in my own array library with relatively little difficulty.

Matthias