Vector.h

Go to the documentation of this file.
00001 
00005 #ifndef Vector_h
00006 #define Vector_h
00007 
00008 
00009 #include "Math.h"
00010 #include <iosfwd>
00011 #include <math.h>
00012 
00013 class Point;
00014 class Vector {
00015  public:
00016   Vector() {
00017   }
00018   Vector(double x, double y, double z) {
00019     data[0] = x; data[1] = y; data[2] = z;
00020   }
00021   inline explicit Vector(const Point& copy);
00022 
00023   Vector(const Vector& copy) {
00024     for(int i=0;i<3;i++)
00025       data[i] = copy.data[i];
00026   }
00027 
00028   Vector& operator=(const Vector& copy) {
00029     for(int i=0;i<3;i++)
00030       data[i] = copy.data[i];
00031     return *this;
00032   }
00033 
00034   ~Vector() {
00035   }
00036 
00037   double x() const {
00038     return data[0];
00039   }
00040   double y() const {
00041     return data[1];
00042   }
00043   double z() const {
00044     return data[2];
00045   }
00046 
00047   Vector operator+(const Vector& v) const {
00048     return Vector(data[0]+v.data[0], data[1]+v.data[1], data[2]+v.data[2]);
00049   }
00050   Vector operator-(const Vector& v) const {
00051     return Vector(data[0]-v.data[0], data[1]-v.data[1], data[2]-v.data[2]);
00052   }
00053   Vector operator-() const {
00054     return Vector(-data[0], -data[1], -data[2]);
00055   }
00056   Vector& operator+=(const Vector& v) {
00057     data[0]+=v.data[0]; data[1]+=v.data[1]; data[2]+=v.data[2];
00058     return *this;
00059   }
00060   Vector& operator-=(const Vector& v) {
00061     data[0]-=v.data[0]; data[1]-=v.data[1]; data[2]-=v.data[2];
00062     return *this;
00063   }
00064 
00065   Vector operator*(const Vector& v) const {
00066     return Vector(data[0]*v.data[0], data[1]*v.data[1], data[2]*v.data[2]);
00067   }
00068   Vector operator*(double s) const {
00069     return Vector(data[0]*s, data[1]*s, data[2]*s);
00070   }
00071   Vector& operator*=(const Vector& v) {
00072     data[0]*=v.data[0]; data[1]*=v.data[1]; data[2]*=v.data[2];
00073     return *this;
00074   }
00075   Vector& operator*=(double s) {
00076     data[0]*=s; data[1]*=s; data[2]*=s;
00077     return *this;
00078   }
00079   Vector operator/(double s) const {
00080     double inv_s = 1./s;
00081     return Vector(data[0]*inv_s, data[1]*inv_s, data[2]*inv_s);
00082   }
00083   Vector& operator/=(double s) {
00084     double inv_s = 1./s;
00085     data[0]*=inv_s; data[1]*=inv_s; data[2]*=inv_s;
00086     return *this;
00087   }
00088   Vector operator/(const Vector& v) const {
00089     return Vector(data[0]/v.data[0], data[1]/v.data[1], data[2]/v.data[2]);
00090   }
00091 
00092   double length() const {
00093     return sqrt(data[0]*data[0]+data[1]*data[1]+data[2]*data[2]);
00094   }
00095   double length2() const {
00096     return data[0]*data[0]+data[1]*data[1]+data[2]*data[2];
00097   }
00098 
00099   double normalize() {
00100     double len = length();
00101     double scale = 1.0/len;
00102     *this *= scale;
00103     return len;
00104   }
00105   double minComponent() const {
00106     return Min(data[0], data[1], data[2]);
00107   }
00108   double maxComponent() const {
00109     return Max(data[0], data[1], data[2]);
00110   }
00111 
00112   Vector inverse() const {
00113     return Vector(1./data[0], 1./data[1], 1./data[2]);
00114   }
00115   Vector absoluteValue() const {
00116     return Vector(Abs(data[0]), Abs(data[1]), Abs(data[2]));
00117   }
00118 
00119   static Vector zero() {
00120     return Vector(0,0,0);
00121   }
00122   static Vector one() {
00123     return Vector(1,1,1);
00124   }
00125 
00126  private:
00127   double data[3];
00128 };
00129 
00130 #include "Point.h"
00131 
00132 inline Vector::Vector(const Point& copy)
00133 {
00134   data[0] = copy.x(); data[1] = copy.y(); data[2] = copy.z();
00135 }
00136 
00137 inline Vector operator*(double s, const Vector& v) {
00138   return Vector(s*v.x(), s*v.y(), s*v.z());
00139 }
00140 
00141 inline double Dot(const Vector& v1, const Vector& v2)
00142 {
00143   return v1.x()*v2.x() + v1.y()*v2.y() + v1.z()*v2.z();
00144 }
00145 
00146 inline Vector Cross(const Vector& v1, const Vector& v2)
00147 {
00148   return Vector(v1.y()*v2.z() - v1.z()*v2.y(),
00149                 v1.z()*v2.x() - v1.x()*v2.z(),
00150                 v1.x()*v2.y() - v1.y()*v2.x());
00151 }
00152 
00153 inline Vector Min(const Vector& p1, const Vector& p2)
00154 {
00155   return Vector(Min(p1.x(), p2.x()), Min(p1.y(), p2.y()), Min(p1.z(), p2.z()));
00156 }
00157 
00158 inline Vector Max(const Vector& p1, const Vector& p2)
00159 {
00160   return Vector(Max(p1.x(), p2.x()), Max(p1.y(), p2.y()), Max(p1.z(), p2.z()));
00161 }
00162 
00163 std::ostream& operator<<(std::ostream&, const Vector& v);
00164 
00165 #endif

Generated on Tue Jan 29 21:34:54 2008 for specter by  doxygen 1.4.6