Re: [Boost-users] [tuple] Tuple arithmetic

Subject: Re: [Boost-users] [tuple] Tuple arithmetic
From: Bill Buklis (boostusr_at_[hidden])
Date: 2012-02-10 13:21:22

On 2/10/2012 2:50 AM, Philipp Moeller wrote:
> Bill Buklis<boostusr_at_[hidden]>  writes:
>
>> Is there any facility to perform arithmetic operations on a tuple?
>>
>> For example:
>>
>>      struct data
>>      {
>>          double    a, b;
>>      };
>>
>>      data    d1 = {1.0, 2.0};
>>      data    d2 = {2.5, 5.5};
>>
>>      // These two lines are not valid, but simulate what I want.
>>      boost::tie(d1.a, d1.b) *= 10.0;        // Multiply each element by 10.0
>>      boost::tie(d1.a, d1.b) += boost::tie(d2.a, d2.b);    // Add the
>> elements from the second object
>>
>> After calculations, d1 should equal {12.5, 25.5};
> Using a tuple this way is probably not the best idea. Tuples are
> intended for heterogeneous types. If all you really want is a fixed
> length container for doubles you should use boost/std::array<double>.
>
> If you really insist on the tuple, here is
>
> tuple_for_each isn't that hard:
>
> template<class T, class F>
> inline void for_each(boost::tuples::cons<T, boost::tuples::null_type>
> const&  tuple, F f)
> {
>       f(tuple.get_head());
> }
>
> template<class T, class U, class F>
> inline void for_each(boost::tuples::cons<T, U>  const&  tuple, F f)
> {
>       f(tuple.get_head());
>       for_each(tuple.get_tail(), f);
> }
>
> double a, b;
> for_each(tie(a,b), [](double&  x) { x *= 10.0; })
>
> HTH,
> Philipp Moeller
>

Thanks. That looks interesting. In my example I only used doubles, but I 
was thinking in the more general sense where the types may be different 
as long as they were compatible with the operand. The second example 
could easily have different types, since it only matters that a1 is 
compatible with a2, b1 is compatible with b2, and so on.

In my specific case that made me think of this, I had a structure with 
several elements in it. An array was unsuitable and unnecessary. I was 
just wondering if there was something similar to the comparison 
operators for tuple rather than having to add extra operators for the 
structure. For this case I just went ahead and added them.

I guess it seemed logical that tuple could have arithmetic operators (at 
least for example 2) that act just like the comparison operators that 
operate on each like element in turn. From your example it looks like it 
would be fairly easy to write one. I don't know what the pros and cons 
would be for having that in the library.

-- 
Bill