static or not?

[michael.goossens]

Whats the best way to implement this:

BBox BBox::Union(const BBox &b) const{
BBox u;
u.p_min.x = min(p_min.x, b.p_min.x); u.p_min.y = min(p_min.y,
b.p_min.y); u.p_min.z = min(p_min.z, b.p_min.z);
u.p_max.x = max(p_max.x, b.p_max.x); u.p_max.y = max(p_max.y,
b.p_max.y); u.p_max.z = max(p_max.z, b.p_max.z);
return u;
}

or static with two arguments. I'm thinking of making this inline ...
but I don't know why anyone supporting this?

[michael.goossens]

ooo, great suggestion:
return BBox(min( p_min, other.p_min ), max( p_max, other.p_max ));

I didn't know min and max worked for other types than the primitives.

[kwikius]

On Jan 28, 2:12*pm, "Alf P. Steinbach" <[e-mail]:

Whether to use the names "min" and "max" is another matter, which I
think can only be resolved by thinking about what makes sense (or not)
in your problem domain, and whether you plan on using or suspect you
might in future be using std::max or std::min for Point3D.

FWIW I don't see min and max being useful for points and vectors.

The only possible use is if you treat a vector as a sequence and then
do min or max on each element:

#include <vector>
#include <algorithm>
#include <iostream>

int main()
{
typedef std::vector<doublevect;

vect v1, v2, r_min(3), r_max(3);
v1.push_back(1);
v1.push_back(2);
v1.push_back(3);

v2.push_back(0.5);
v2.push_back(3);
v2.push_back(-1);

typedef double const &(*pf)(double const &, double const &);
std::transform(v1.begin(), v1.end(),
v2.begin(),r_min.begin(),pf(std::min));

for ( std::size_t i = 0; i < r_min.size(); ++i){
std::cout << r_min[i] <<'\n';
}
std::cout << "......\n";
std::transform(v1.begin(), v1.end(),
v2.begin(),r_max.begin(),pf(std::max));

for ( std::size_t i = 0; i < r_max.size(); ++i){
std::cout << r_max[i] <<'\n';
}

}

You can of course also write a version that acts on a tuple.

Alternatively xmin(Pt,Pt), ymin(Pt,Pt),zmin(Pt,Pt) are useful
returning the minimum x and y of the 2 points. In this case its
similar to writing out each iteration of the sequence.

OTOH funnily enough min and max could make sense for a bounding
box :-)

regards
Andy Little

[kwikius]

On Jan 29, 12:14*pm, "Alf P. Steinbach" <[e-mail]:

* kwikius:

Could add that its an unnecessary requirement AFAICS. (Perhaps the
return type was changed from value to const reference at some point.)

#include <algorithm>
#include <iostream>

struct my{
explicit *my (double v_in) : v (v_in){};
* double v;
private :
* *my ( my const &);

};

inline bool operator <
(my const & lhs, my const & rhs)
{
* *return lhs.v *< rhs.v;
}

int main()
{
* my x(1),y(2);
* my const & r = std::min(x,y);

Consider instead

* *my const& r = std::min( x, my(2) );

Ouch!. But Isnt whether 'my' is copy constructible or not irrelevant
here. It will still screw up just the same ?

hmmm....

<...>

I wonder if the code above will be valid in C++0x, and if so, how the
heck the compiler could implement the necessary lifetime extension for
the temporary?

hmm.... Mental note!

I'll look at the move constructible widget when it materialises,
meanwhile my overloads of min/max will return by value.

:-)

regards
Andy Little