Boost logo

Boost :

From: Leland Brown (lelandbrown_at_[hidden])
Date: 2006-06-09 00:07:17

Michael Fawcett <michael.fawcett <at>> writes:
> Contrived example using theoretical code:
> // Multiply accumulate (Is there a simpler way?)
> template
> <
> typename X, typename Y, typename Z,
> typename VX, typename VY, typename VZ
> >
> struct macc
> {
> // X * VX + Y * VY + Z * VZ
> typedef typename boost::result_of_multiplies<X, VX>::type x_times_x;
> typedef typename boost::result_of_multiplies<Y, VY>::type y_times_y;
> typedef typename boost::result_of_multiplies<Z, VZ>::type z_times_z;
> typedef typename boost::result_of_plus<y_times_y, z_times_z>::type
> y_times_y_plus_z_times_z;
> typedef typename boost::result_of_plus<x_times_x,
> y_times_y_plus_z_times_z>::type x_plus_y_plus_z;
> typedef x_plus_y_plus_z type;
> };
> template
> <
> typename X, typename Y, typename Z,
> typename VX, typename VY, typename VZ
> >
> typename macc<X, Y, Z, VX, VY, VZ>::type
> dot_product(const vec3<X, Y, Z> &lhs, const vec3<VX, VY, VZ> &rhs)
> {
> return lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
> }

Yes, surely a matrix library written like this could do the trick for PQS. But
it has its limitations too - see my other comment below.

> This would require the math library be more heavily templated than it
> currently is. Note that a matrix would need to hold mutliple types
> (up to NxN). For instance, what would be the syntax for a 3D
> transform? Perhaps something like:
> matrix4x4
> <
> float, float, float, length,
> float, float, float, length,
> float, float, float, length,
> length, length, length, float
> > m;

But consider the following situation (which, though it may sound contrived, is
pretty similar to what came up in my real application), Suppose I have a
compile-time constant like

   const int NUM_OF_ITEMS = 5;

And I need a vector containing 3 dimensionless quantities, a time, and
NUM_OF_ITEMS length values. And then I need a scaling matrix for that! Yes,
the value "5" is known a priori, and I could write out the whole 10x10
transform. But I've defined NUM_OF_ITEMS as a symbolic constant because it's
subject to change. Next month I find out we have 7 items instead of 5. I'd
like it to be a single-point code change:

   const int NUM_OF_ITEMS = 7;

Can I get the compiler to generate the 12x12 matrix definition for me? I bet
it's theoretically possible with template metaprogramming, but I doubt it would
be worth anybody's time to implement such a monster.

This is the point where I threw up my hands and accepted that I was going to
need the t3_quantity.

-- Leland

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