Boost logo

Boost :

From: Torsten Maehne (Torsten.Maehne_at_[hidden])
Date: 2008-06-06 09:51:54

Hello Steven,

thank you for helping me in debugging lambda.hpp!

Steven Watanabe wrote:
> Torsten Maehne wrote:
>>>> * All checks involving the multiplication/division of
>>>> boost::units::unit and boost::units::absolute<boost::units::unit>
>>>> types are not compiling. The compiler complains about ambiguous
>>>> overloads for operator* and operator/ (originating from Boost.Units
>>>> and Boost.Lambda). Therefore they are currently commented out.
>>> These shouldn't compile.
>> I modified the checks so that now units and absolute units are passed as
>> well as arguments to the lambda expressions. Then the ambiguous overload
>> errors disappear. However, for the absolute unit tests:
>> <snip>
>> I left the non-compiling commented-out tests in place for documentation
>> purposes.
> I looked at the tests. I misunderstood what you were testing.
> Allowing multiplication _1 * meters e.g. would require disambiguating
> overloads.

I have tried to add specializations to lambda.hpp like the following:

    /// Partial specialization of return type trait for action
    /// boost::lambda::functor<T> * unit<Dim, System>.
    template<typename System, typename Dim, typename T>
    struct plain_return_type_2<arithmetic_action<multiply_action>,
                               boost::units::unit<Dim, System> > {
        typedef typename boost::units::multiply_typeof_helper<
            boost::units::unit<Dim, System> >::type type;

, to disambiguate the overloads. However the specialization seems to be
not picked up by the compiler -- it still uses either:

boost::lambda::functor<T> * Y


Y * unit<Dim, System>

when uncommenting the check for bl::_1 * bu::meters in test_lambda.cpp.
(Note: I didn't add the specialization to the attached corrected
lambda.hpp.) Do you have an idea, what I'm doing wrong here?

>>>> * The check of unit<Dim1, System1> - unit<Dim2, System2> is not
>>>> compiling. The compiler finds no matching definition of operator-.
>>> Again these shouldn't compile.
>> This strikes me as being inconsistent, because it works for:
>> unit<Dim1, System1> + unit<Dim2, System2>
> I see. I didn't understand what you were testing, again.
> The problem is in units/lambda.hpp line 390 ff.
> /// Partial specialization of return type trait for action
> /// unit<Dim1, System1> - unit<Dim2, System2>.
> template<typename Dim1, typename Dim2, typename System1, typename
> System2>
> struct plain_return_type_2<arithmetic_action<minus_action>,
> boost::units::unit<Dim1, System1>,
> boost::units::unit<Dim2, System2> > {
> BOOST_STATIC_ASSERT((boost::is_same<System1, System2>::value ==
> true));
> typedef typename boost::units::subtract_typeof_helper<
> boost::units::*quantity*<Dim1, System1>,
> boost::units::*quantity*<Dim2, System2> >::type type;
> };
> These two quantities ought to be units.

Thanks for pointing me to this nasty copy & paste error. I corrected it
in the attached new lambda.hpp.

Best regards,


Boost list run by bdawes at, gregod at, cpdaniel at, john at