Boost logo

Boost Users :

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.


Boost-users list run by williamkempf at, kalb at, bjorn.karlsson at, gregod at, wekempf at