[tuple] Tuple arithmetic
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}; Thanks, -- Bill
On Thu, Feb 9, 2012 at 5:46 PM, Bill Buklis <boostusr@pbjzone.com> wrote:
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};
Boost.Fusion + Boost.Phoenix *might* be what you're looking for, but I don't know. Specifically, boost::fusion::for_each [1] lets you iterate over a tuple and apply a (polymorphic) function to each element; that function can be built inline using Boost.Phoenix. E.g., (untested) boost::fusion::for_each(d1, boost::phoenix::arg_names::_1 *= 10.0); Your second example above might be a bit more verbose using these techniques. Check out also boost::fusion::transform [2] and, maybe, boost::fusion::zip_view [3]? Also, you'll have to adapt [4] your data struct to be recognizable as a Boost.Fusion sequence. [1] http://www.boost.org/doc/libs/1_48_0/libs/fusion/doc/html/fusion/algorithm/i... [2] http://www.boost.org/doc/libs/1_48_0/libs/fusion/doc/html/fusion/algorithm/t... [3] http://www.boost.org/doc/libs/1_48_0/libs/fusion/doc/html/fusion/view/zip_vi... [4] http://www.boost.org/doc/libs/1_48_0/libs/fusion/doc/html/fusion/adapted/ada... - Jeff
Bill Buklis <boostusr@pbjzone.com> 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
Philipp Moeller <philipp.moeller@geometryfactory.com> writes:
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); }
Proper attribution is missing. I took the code from this message on the boost mailing list http://lists.boost.org/Archives/boost/2004/09/72919.php -- Philipp Moeller
On 2/10/2012 2:50 AM, Philipp Moeller wrote:
Bill Buklis<boostusr@pbjzone.com> 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
On 02/10/2012 07:21 PM, Bill Buklis wrote:
On 2/10/2012 2:50 AM, Philipp Moeller wrote:
Bill Buklis<boostusr@pbjzone.com> 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.
As Jeffrey already noted, this is where fusion + phoenix really starts to shine. Especially if you have a tuple with different data types, you won't get far with C++11 lambdas. Using fusion::for_each, fusion::transform with an appropriate phoenix expression might do the trick here. Note that tuples are a very generic datatype, it wouldn't make a lot of sense to add some special operators to them. If you think in a functional programming kind of, phoenix is the answer.
As Jeffrey already noted, this is where fusion + phoenix really starts to shine. Especially if you have a tuple with different data types, you won't get far with C++11 lambdas. Using fusion::for_each, fusion::transform with an appropriate phoenix expression might do the trick here. Note that tuples are a very generic datatype, it wouldn't make a lot of sense to add some special operators to them. If you think in a functional programming kind of, phoenix is the answer.
So far I've only scratched the surface of fusion and phoenix. I will have to delve into them a little more deeply at some point. Right now this is more of a thought experiment that anything else. Thanks everyone for your insight. -- Bill
participants (4)
-
Bill Buklis -
Jeffrey Lee Hellrung, Jr. -
Philipp Moeller -
Thomas Heller