OOPSE/utils/Vector3.hpp

#ifndef _VECTOR3_H_
#define _VECTOR3_H_
#include <iostream>
//generic vector3 class
template<typename Real> class Vector3{
  public:
    inline Vector3();
    inline Vector3( Real x, Real y, Real z);
    inline Vector3( Real* a);
    inline Vector3( const Vector3<Real>& v1 );
    inline ~Vector3() {}
    inline Vector3<Real>& operator=( const Vector3<Real>& v1 );

    inline Real& operator[](unsigned int  i) {return vec3[i];}
     
    inline  const Real& operator[](unsigned int i) const {return vec3[i];}

     inline bool operator ==( const Vector3<Real>& v1 );
      
    inline bool operator !=( const Vector3<Real>& v1);

    inline void neg();

    inline void add( const Vector3<Real>& v1 );

    inline void add( const Vector3<Real>& v1, const Vector3<Real>  &v2 );

    inline void sub( const Vector3<Real>& v1 );

    inline void sub( const Vector3<Real>& v1, const Vector3<Real>  &v2 );

    inline void mul( Real r );

    inline void mul( Real r, const Vector3<Real>& v1 );

    inline void mul( const Vector3<Real>& v1, Real r );
      
    inline void div( Real r);
     
    inline void div( const Vector3<Real>& v1, Real r );
     
    inline void operator +=( const Vector3<Real>& v1 );
       
    inline void operator -=( const Vector3<Real>& v1 );
      
    inline void operator *=( Real r );
      
    inline void operator /=( Real r );
      
    inline Vector3<Real> operator+( const Vector3<Real>& v1) const;
      
    inline Vector3<Real> operator-( const Vector3<Real>& v1) const;

    inline Vector3<Real> operator*( Real r) const;

    inline Vector3<Real> operator/( Real r) const;
    
    friend Vector3<Real> operator* ( Real r, const Vector3<Real>& v1 );
       
    friend Vector3<Real> operator* ( const Vector3<Real>& v1, Real r);
              
    inline Real norm() const;
      
    inline Real abs() const;
      
    inline int normalize();

    static inline Real length( const Vector3<Real>& v1, const Vector3<Real>& v2 );

    static inline Real dot( const Vector3<Real>& v1, const Vector3<Real>& v2 ); 

    friend std::ostream &operator<< ( std::ostream& o, const Vector3<Real>& v1 );

    //use anonymous union and struct to provide the transparency for operator []  
    //is it compiler and platform independent?
    union{
      Real vec[3];

      struct{
        Real x;
        Real y;
        Real z;
      };    
    };
};


template<typename Real> Vector3<Real>::Vector3(){
  this->x = Real();
  this->y = Real();
  this->z = Real();
  
}

template<typename Real> Vector3<Real>::Vector3( Real x, Real y, Real z){
  this->x = x;
  this->y = y;
  this->z = z;
}

template<typename Real> Vector3<Real>::Vector3(Real* r){
  this->x = r[0];
  this->y = r[1];
  this->z = r[2];
}

template<typename Real> Vector3<Real>::Vector3(const Vector3<Real>& v1){
  this->x = v1.x;
  this->y = v1.y;  
  this->z = v1.z;
}

template<typename Real> Vector3<Real>& Vector3<Real>::operator=( const Vector3<Real>& v1 ){
  if(this == & v1)
    return *this;
  
  this->x = v1.x
  this->y = v1.y;  
  this->z = v1.z;

  return *this;
}

template<typename Real> bool Vector3<Real>::operator ==( const Vector3<Real>& v1 ){
  return this->x == v1.x && this->y == v1.y && this->z == v1.z;
}

template<typename Real> bool Vector3<Real>::operator !=( const Vector3<Real>& v1 ){
  return this->x != v1.x || this->y != v1.y || this->z != v1.z;
}

template<typename Real>  void Vector3<Real>::neg(){
  this->x = -this->x;
  this->y = -this->y;
  this->z = -this->z;
}

template<typename Real>  void Vector3<Real>::add( const Vector3<Real>& v1 ){
  this->x += v1.x;
  this->y += v1.y;
  this->z += v1.z;
}

template<typename Real>  void Vector3<Real>::add( const Vector3<Real>& v1, const Vector3<Real>  &v2 ){
  this->x = v1.x + v1.x;
  this->y = v1.y + v2.y;
  this->z = v1.z + v2.z;

}
    
template<typename Real>  void Vector3<Real>::sub( const Vector3<Real>& v1 ){
  this->x -= v1.x;
  this->y -= v1.y;
  this->z -= v1.z;
}

template<typename Real>  void Vector3<Real>::sub( const Vector3<Real>& v1, const Vector3<Real>  &v2 ){
  this->x = v1.x - v1.x;
  this->y = v1.y - v2.y;
  this->z = v1.z - v2.z;
}

template<typename Real>  void Vector3<Real>::mul( Real r ){
  this->x *= r;
  this->y *= r;
  this->z *= r;
}

template<typename Real>  void Vector3<Real>::mul( Real r, const Vector3<Real>& v1 ){
  this->x = r * v1.x;
  this->y = r * v1.y;
  this->z = r * v1.z;

}

template<typename Real>  void Vector3<Real>::mul( const Vector3<Real>& v1, Real r ){
  this->x = v1.x * r;
  this->y = v1.y * r;
  this->z = v1.z * r;
}

template<typename Real>  void Vector3<Real>::div( Real r){
  this->x /= r;
  this->y /= r;
  this->z /= r;
}
     
template<typename Real>  void Vector3<Real>::div( const Vector3<Real>& v1, Real r ){
  this->x = v1.x/r;
  this->y = v1.y/r;
  this->z = v1.z/r;
}

template<typename Real> void Vector3<Real>::operator +=( const Vector3<Real>& v1 ){
  this->x += v1.x;
  this->y += v1.y;
  this->z += v1.z;
}
       
template<typename Real> void Vector3<Real>::operator -=( const Vector3<Real>& v1 ){
  this->x -= v1.x;
  this->y -= v1.y;
  this->z -= v1.z;
}
      
template<typename Real> void Vector3<Real>::operator *=( Real r ){
  this->x *= r;
  this->y *= r;
  this->z *= r;
}
      
template<typename Real> void Vector3<Real>::operator /=( Real r ){
  this->x /= r;
  this->y /= r;
  this->z /= r;
}
    
template<typename Real> Vector3<Real> Vector3<Real>::operator+( const Vector3<Real>& v1) const{
  return Vector3<Real>(x + v1.x, y + v1.y, z + v1.z);
}
      
template<typename Real> Vector3<Real> Vector3<Real>::operator-( const Vector3<Real>& v1) const{
  return Vector3<Real>(x - v1.x, y - v1.y, z - v1.z);
}

template<typename Real> Vector3<Real> Vector3<Real>::operator*( Real r) const{
  return Vector3<Real>(x*r, y*r, z*r);
}
      
template<typename Real> Vector3<Real> Vector3<Real>::operator /( Real r) const{
  return Vector3<Real>(x/r, y/r, z/r);
}


template <typename Real> Vector3<Real> operator* ( Real r, const Vector3<Real>& v1 ){
  return  Vector<Real>(v1.x * r, v1.y * r, v1.z * r);

}
       
template <typename Real> Vector3<Real> operator* ( const Vector3<Real>& v1, Real r){
  return  Vector<Real>(v1.x * r, v1.y * r, v1.z * r);
}
    
typedef  Vector3<double> Vector3d;
typedef Vector3<float> Vector3f;

#endif //_VECTOR3_H_

Revision:	1162
Committed:	Tue May 11 22:28:57 2004 UTC (21 years, 5 months ago) by tim
File size:	6324 byte(s)
Log Message:	adding generic Vector3 class
#	Content
1	#ifndef _VECTOR3_H_
2	#define _VECTOR3_H_
3	#include <iostream>
4	//generic vector3 class
5	template<typename Real> class Vector3{
6	public:
7	inline Vector3();
8	inline Vector3( Real x, Real y, Real z);
9	inline Vector3( Real* a);
10	inline Vector3( const Vector3<Real>& v1 );
11	inline ~Vector3() {}
12	inline Vector3<Real>& operator=( const Vector3<Real>& v1 );
13
14	inline Real& operator[](unsigned int i) {return vec3[i];}
15
16	inline const Real& operator[](unsigned int i) const {return vec3[i];}
17
18	inline bool operator ==( const Vector3<Real>& v1 );
19
20	inline bool operator !=( const Vector3<Real>& v1);
21
22	inline void neg();
23
24	inline void add( const Vector3<Real>& v1 );
25
26	inline void add( const Vector3<Real>& v1, const Vector3<Real> &v2 );
27
28	inline void sub( const Vector3<Real>& v1 );
29
30	inline void sub( const Vector3<Real>& v1, const Vector3<Real> &v2 );
31
32	inline void mul( Real r );
33
34	inline void mul( Real r, const Vector3<Real>& v1 );
35
36	inline void mul( const Vector3<Real>& v1, Real r );
37
38	inline void div( Real r);
39
40	inline void div( const Vector3<Real>& v1, Real r );
41
42	inline void operator +=( const Vector3<Real>& v1 );
43
44	inline void operator -=( const Vector3<Real>& v1 );
45
46	inline void operator *=( Real r );
47
48	inline void operator /=( Real r );
49
50	inline Vector3<Real> operator+( const Vector3<Real>& v1) const;
51
52	inline Vector3<Real> operator-( const Vector3<Real>& v1) const;
53
54	inline Vector3<Real> operator*( Real r) const;
55
56	inline Vector3<Real> operator/( Real r) const;
57
58	friend Vector3<Real> operator* ( Real r, const Vector3<Real>& v1 );
59
60	friend Vector3<Real> operator* ( const Vector3<Real>& v1, Real r);
61
62	inline Real norm() const;
63
64	inline Real abs() const;
65
66	inline int normalize();
67
68	static inline Real length( const Vector3<Real>& v1, const Vector3<Real>& v2 );
69
70	static inline Real dot( const Vector3<Real>& v1, const Vector3<Real>& v2 );
71
72	friend std::ostream &operator<< ( std::ostream& o, const Vector3<Real>& v1 );
73
74	//use anonymous union and struct to provide the transparency for operator []
75	//is it compiler and platform independent?
76	union{
77	Real vec[3];
78
79	struct{
80	Real x;
81	Real y;
82	Real z;
83	};
84	};
85	};
86
87
88	template<typename Real> Vector3<Real>::Vector3(){
89	this->x = Real();
90	this->y = Real();
91	this->z = Real();
92
93	}
94
95	template<typename Real> Vector3<Real>::Vector3( Real x, Real y, Real z){
96	this->x = x;
97	this->y = y;
98	this->z = z;
99	}
100
101	template<typename Real> Vector3<Real>::Vector3(Real* r){
102	this->x = r[0];
103	this->y = r[1];
104	this->z = r[2];
105	}
106
107	template<typename Real> Vector3<Real>::Vector3(const Vector3<Real>& v1){
108	this->x = v1.x;
109	this->y = v1.y;
110	this->z = v1.z;
111	}
112
113	template<typename Real> Vector3<Real>& Vector3<Real>::operator=( const Vector3<Real>& v1 ){
114	if(this == & v1)
115	return *this;
116
117	this->x = v1.x
118	this->y = v1.y;
119	this->z = v1.z;
120
121	return *this;
122	}
123
124	template<typename Real> bool Vector3<Real>::operator ==( const Vector3<Real>& v1 ){
125	return this->x == v1.x && this->y == v1.y && this->z == v1.z;
126	}
127
128	template<typename Real> bool Vector3<Real>::operator !=( const Vector3<Real>& v1 ){
129	return this->x != v1.x \|\| this->y != v1.y \|\| this->z != v1.z;
130	}
131
132	template<typename Real> void Vector3<Real>::neg(){
133	this->x = -this->x;
134	this->y = -this->y;
135	this->z = -this->z;
136	}
137
138	template<typename Real> void Vector3<Real>::add( const Vector3<Real>& v1 ){
139	this->x += v1.x;
140	this->y += v1.y;
141	this->z += v1.z;
142	}
143
144	template<typename Real> void Vector3<Real>::add( const Vector3<Real>& v1, const Vector3<Real> &v2 ){
145	this->x = v1.x + v1.x;
146	this->y = v1.y + v2.y;
147	this->z = v1.z + v2.z;
148
149	}
150
151	template<typename Real> void Vector3<Real>::sub( const Vector3<Real>& v1 ){
152	this->x -= v1.x;
153	this->y -= v1.y;
154	this->z -= v1.z;
155	}
156
157	template<typename Real> void Vector3<Real>::sub( const Vector3<Real>& v1, const Vector3<Real> &v2 ){
158	this->x = v1.x - v1.x;
159	this->y = v1.y - v2.y;
160	this->z = v1.z - v2.z;
161	}
162
163	template<typename Real> void Vector3<Real>::mul( Real r ){
164	this->x *= r;
165	this->y *= r;
166	this->z *= r;
167	}
168
169	template<typename Real> void Vector3<Real>::mul( Real r, const Vector3<Real>& v1 ){
170	this->x = r * v1.x;
171	this->y = r * v1.y;
172	this->z = r * v1.z;
173
174	}
175
176	template<typename Real> void Vector3<Real>::mul( const Vector3<Real>& v1, Real r ){
177	this->x = v1.x * r;
178	this->y = v1.y * r;
179	this->z = v1.z * r;
180	}
181
182	template<typename Real> void Vector3<Real>::div( Real r){
183	this->x /= r;
184	this->y /= r;
185	this->z /= r;
186	}
187
188	template<typename Real> void Vector3<Real>::div( const Vector3<Real>& v1, Real r ){
189	this->x = v1.x/r;
190	this->y = v1.y/r;
191	this->z = v1.z/r;
192	}
193
194	template<typename Real> void Vector3<Real>::operator +=( const Vector3<Real>& v1 ){
195	this->x += v1.x;
196	this->y += v1.y;
197	this->z += v1.z;
198	}
199
200	template<typename Real> void Vector3<Real>::operator -=( const Vector3<Real>& v1 ){
201	this->x -= v1.x;
202	this->y -= v1.y;
203	this->z -= v1.z;
204	}
205
206	template<typename Real> void Vector3<Real>::operator *=( Real r ){
207	this->x *= r;
208	this->y *= r;
209	this->z *= r;
210	}
211
212	template<typename Real> void Vector3<Real>::operator /=( Real r ){
213	this->x /= r;
214	this->y /= r;
215	this->z /= r;
216	}
217
218	template<typename Real> Vector3<Real> Vector3<Real>::operator+( const Vector3<Real>& v1) const{
219	return Vector3<Real>(x + v1.x, y + v1.y, z + v1.z);
220	}
221
222	template<typename Real> Vector3<Real> Vector3<Real>::operator-( const Vector3<Real>& v1) const{
223	return Vector3<Real>(x - v1.x, y - v1.y, z - v1.z);
224	}
225
226	template<typename Real> Vector3<Real> Vector3<Real>::operator*( Real r) const{
227	return Vector3<Real>(xr, yr, z*r);
228	}
229
230	template<typename Real> Vector3<Real> Vector3<Real>::operator /( Real r) const{
231	return Vector3<Real>(x/r, y/r, z/r);
232	}
233
234
235	template <typename Real> Vector3<Real> operator* ( Real r, const Vector3<Real>& v1 ){
236	return Vector<Real>(v1.x * r, v1.y * r, v1.z * r);
237
238	}
239
240	template <typename Real> Vector3<Real> operator* ( const Vector3<Real>& v1, Real r){
241	return Vector<Real>(v1.x * r, v1.y * r, v1.z * r);
242	}
243
244	typedef Vector3<double> Vector3d;
245	typedef Vector3<float> Vector3f;
246
247	#endif //_VECTOR3_H_
248