Vector.h

Go to the documentation of this file.
00001 // vim:set noet ts=8 sw=8:
00002 #ifndef VECTOR_H_
00003 #define VECTOR_H_
00004 
00005 #include <string.h>
00006 #define _USE_MATH_DEFINES
00007 #include <math.h>
00008 #include "FloatUtils.h"
00009 
00014 template<class T = float>
00015 class Vector {
00016         public:
00017                 Vector (T x = 0, T y = 0, T z = 0) {
00018                         mCoords[0] = x;
00019                         mCoords[1] = y;
00020                         mCoords[2] = z;
00021                 }
00022 
00023                 // standard copy-ctor, assignment op. and dtor suffice
00024 
00025                 T x() const { return mCoords[0]; }
00026                 T y() const { return mCoords[1]; }
00027                 T z() const { return mCoords[2]; }
00028 
00029                 void setX(T x) { mCoords[0] = x; }
00030                 void setY(T y) { mCoords[1] = y; }
00031                 void setZ(T z) { mCoords[2] = z; }
00032 
00033                 T* vector() { return mCoords; }
00034                 const T* vector() const { return mCoords; }
00035 
00036                 operator T*() { return vector(); }
00037 
00038                 Vector<T> operator +=(const Vector<T>& v) {
00039                         mCoords[0] += v.x();
00040                         mCoords[1] += v.y();
00041                         mCoords[2] += v.z();
00042                         return *this;
00043                 }
00044                 Vector<T> operator+(const Vector<T>& v) const {
00045                         Vector<T> r(*this);
00046                         return r += v;
00047                 }
00048 
00049                 Vector<T> operator -=(const Vector<T>& v) {
00050                         mCoords[0] -= v.x();
00051                         mCoords[1] -= v.y();
00052                         mCoords[2] -= v.z();
00053                         return *this;
00054                 }
00055                 Vector<T> operator-(const Vector<T>& v) const {
00056                         Vector<T> r(*this);
00057                         return r -= v;
00058                 }
00059 
00060                 Vector<T> operator-() const {
00061                         return Vector<T>(-x(), -y(), -z());
00062                 }
00063 
00064                 // cross product
00065                 Vector<T> operator*=(const Vector<T>& b) {
00066                         T xval = y() * b.z() - b.y() * z();
00067                         T yval = b.x() * z() - x() * b.z();
00068                         T zval = x() * b.y() - b.x() * y();
00069                         setX(xval);
00070                         setY(yval);
00071                         setZ(zval);
00072                         return *this;
00073                 }
00074                 // cross product
00075                 Vector<T> operator*(const Vector<T>& b) const {
00076                         Vector<T> r(*this);
00077                         return r *= b;
00078                 }
00079 
00080                 //Tdot product (scalar product)
00081                 T dotProduct(const Vector<T>& b) const {
00082                         return x() * b.x() + y() * b.y() + z() * b.z();
00083                 }
00084 
00085                 Vector<T>& operator*=(T scalar) {
00086                         mCoords[0] *= scalar;
00087                         mCoords[1] *= scalar;
00088                         mCoords[2] *= scalar;
00089                         return *this;
00090                 }
00091                 
00092                 Vector<T>& operator+=(T scalar) {
00093                         mCoords[0] += scalar;
00094                         mCoords[1] += scalar;
00095                         mCoords[2] += scalar;
00096                         return *this;
00097                 }
00098                 
00099                 Vector<T> operator*(T scalar) const {
00100                         return Vector<T>(x() * scalar, y() * scalar, z() * scalar);
00101                 }
00102                 Vector<T>& operator/=(float scalar) {
00103                         mCoords[0] /= scalar;
00104                         mCoords[1] /= scalar;
00105                         mCoords[2] /= scalar;
00106                         return *this;
00107                 }
00108                 Vector<T> operator/(float scalar) const {
00109                         return Vector<T>(x() / scalar, y() / scalar, z() / scalar);
00110                 }
00111 
00112                 bool operator==(const Vector<T>& v2) const {
00113                         
00114                         return ((x()==v2.x())&&(y()==v2.y())&&(z()==v2.z()));
00115                 //      if (!floatEq(x(),v2.x())) return false;
00116                 //      if (!floatEq(y(),v2.y())) return false;
00117                 //      if (!floatEq(z(),v2.z())) return false;
00118                 //      return true;
00119                 }
00120                 
00121                 float len() const {
00122                         return sqrt(x()*x() + y()*y() + z()*z());
00123                 }
00124 
00125                 Vector<T> normalized() const {
00126                         return Vector<T>(*this).normalize();
00127                 }
00128 
00129                 Vector<T>& normalize() {
00130                         return operator/=(len());
00131                 }
00132 
00138                 float angle(const Vector<T>& with) const {
00139                         float dotprod = dotProduct(with);
00140                         float frac = dotprod / (len() * with.len());
00141                         return acos(frac);
00142                 }
00143 
00144                 bool operator>=(const Vector<T>& b) const {
00145                         return x() >= b.x() &&
00146                                    y() >= b.y() &&
00147                                    z() >= b.z();
00148                 }
00149 
00150                 bool operator<=(const Vector<T>& b) const {
00151                         return x() <= b.x() &&
00152                                    y() <= b.y() &&
00153                                    z() <= b.z();
00154                 }
00155 
00156                 bool operator<(const Vector<T>& b) const {
00157                         return x() < b.x() &&
00158                                    y() < b.y() &&
00159                                    z() < b.z();
00160                 }
00161 
00162                 bool operator>(const Vector<T>& b) const {
00163                         return x() > b.x() &&
00164                                    y() > b.y() &&
00165                                    z() > b.z();
00166                 }
00167 
00168         private:
00169                 T mCoords[3];
00170 };
00171 
00172 /*
00173 inline bool vector_eq(const Vector<T>& a, const Vector<T>& b, float eps = 0.0005) {
00174         return floatEq(a.x(), b.x(), eps) &&
00175                         floatEq(a.y(), b.y(), eps) &&
00176                         floatEq(a.z(), b.z(), eps);
00177 }*/
00178         
00179 #endif

Generated on Mon Dec 19 00:13:20 2005 for Visualization by  doxygen 1.4.5