On 2007-04-30 21:58, helge wrote:
Zeppe wrote:
>helge wrote:
>>What is the best way to implement a vector in space R3, i.e a vector
holding three floats, supporting arithmetic operations, dot and cross
product etc in c++? is there a standard library class for this?
Not a standard class, but if your requirements are not too high, you can
use the std::valarray<double>. It supports all the aritmetic operation,
it supports the sum of the elements so that the norm and the dot product
it's straightforward, and you'll have to define just the cross product.
you can also hide a little bit of information encapsulating the valarray
into a class:
class R3Vector
: public std::valarray<double>
{
R3Vector()
: std::valarray<double>(0.0, 3)
{
}
R3Vector(double a, double b, double c)
: std::valarray<double>(0.0, 3)
{
(*this)[0] = a;
(*this)[1] = b;
(*this)[2] = c;
}
R3Vector(const valarray<double>& v)
: std::valarray<double>(0.0, 3)
{
if(v.size() != 3)
error
else
copy
}
R3Vector crossProd(const R3Vector& v) const;
};
This seemed like a good solution. However, I'm having som type related
problems when using this approach. Are STL classes ment to be inherited
from like this? e.g when trying to use dynamic_cast I get the error that
source does not support polymorphism. Wouldn't it be better to keep a
valarray<doubleas a member and use it's functionality to simplify
implementations of the norm, dot product and cross product etc?
Please put your reply below the text you are replying to in the future.
No, the STL classes are not meant to be inherited from, and while I have
no experience of it myself I seem to recall that some people have had
some unexpected consequences and private inheritance is usually recommended.
Having worked on a vector and matrix library recently I would advice you
to first take a look at any existing implementations before rolling your
own, especially if your applications is performance sensitive. There are
two scenarios where I think it might be a good idea to make your own,
and that is if you only need a small and simple implementation or if you
have very special needs.
If you decide to make your own you should probably think twice before
using the valarray unless you need its slice features. The reason is
simple, while the valarray was a good idea (a special class to represent
mathematical vectors and arrays that the library/compiler vendors could
heavily optimize) the reality is that, for a number of reasons, it is
just as unoptimized as could be. When I wrote my code I took a look at
the valarray implementation in VS2005 and it was just the same as what I
would have done, loops over elements.
Here's (a modified) part of my vector, I've chosen to parameterize the
type but you could of course hardcode it to float.
template<typename T>
class Vector
{
T data_[3];
public:
// Constructor
Vector(const Vector<T>& v);
// Assignment-operator
Vector<T>& operator=(const Vector<T>& v);
// Accessing
const T& operator()(size_t n) const;
T& operator()(size_t n);
// Operations
Vector<Toperator+(const Vector<T>& v) const;
Vector<Toperator-(const Vector<T>& v) const;
// ...
Vector<T>& operator+=(const Vector<T>& v);
Vector<T>& operator-=(const Vector<T>& v);
// ...
Vector<Toperator-() const;
bool operator==(const Vector<T>& v) const;
bool operator!=(const Vector<T>& v) const;
// Other
T length() const;
Vector<T>& normalize();
// ...
};
--
Erik Wikström
