utils/sysbuilder/Vector3d.hpp

#ifndef _VECTOR3D_H_
#define _VECTOR3D_H_

#include <cmath>
#include <iostream>

using namespace std;

class Vector3d{

  public:

     Vector3d(){
      this->x = double();
      this->y = double();
      this->z = double();
      
    }

     Vector3d( double x, double y, double z){
      this->x = x;
      this->y = y;
      this->z = z;
    }

     Vector3d(double* r){
      this->x = r[0];
      this->y = r[1];
      this->z = r[2];
    }

     Vector3d(const Vector3d& v1){
      this->x = v1.x;
      this->y = v1.y;  
      this->z = v1.z;
    }

    double& operator[](unsigned int index){
      switch (index){
        case 0 :
          return x;

        case 1 :
          return y;

        case 2 :
          return z;

        default:
          cerr << index <<" is invalid index" << endl;
          exit(1);
      }
    }

    const double& operator[](unsigned int index) const{
      switch (index){
        case 0 :
          return x;

        case 1 :
          return y;

        case 2 :
          return z;

        default:
          cerr << index <<" is invalid index" << endl;
          exit(1);
      }
    }

    Vector3d& operator=( const Vector3d& v1 ){
      if(this == & v1)
        return *this;
      
      this->x = v1.x;
      this->y = v1.y;  
      this->z = v1.z;

      return *this;
    }

    bool operator ==( const Vector3d& v1 ){
      return this->x == v1.x && this->y == v1.y && this->z == v1.z;
    }

    bool operator !=( const Vector3d& v1 ){
      return this->x != v1.x || this->y != v1.y || this->z != v1.z;
    }

    void neg(){
      this->x = -this->x;
      this->y = -this->y;
      this->z = -this->z;
    }

    void add( const Vector3d& v1 ){
      this->x += v1.x;
      this->y += v1.y;
      this->z += v1.z;
    }

    void add( const Vector3d& v1, const Vector3d  &v2 ){
      this->x = v1.x + v1.x;
      this->y = v1.y + v2.y;
      this->z = v1.z + v2.z;

    }
        
    void sub( const Vector3d& v1 ){
      this->x -= v1.x;
      this->y -= v1.y;
      this->z -= v1.z;
    }

    void sub( const Vector3d& v1, const Vector3d  &v2 ){
      this->x = v1.x - v1.x;
      this->y = v1.y - v2.y;
      this->z = v1.z - v2.z;
    }

    void mul( double r ){
      this->x *= r;
      this->y *= r;
      this->z *= r;
    }

    void mul( double r, const Vector3d& v1 ){
      this->x = r * v1.x;
      this->y = r * v1.y;
      this->z = r * v1.z;

    }

    void mul( const Vector3d& v1, double r ){
      this->x = v1.x * r;
      this->y = v1.y * r;
      this->z = v1.z * r;
    }

    void div( double r){
      this->x /= r;
      this->y /= r;
      this->z /= r;
    }
         
     void div( const Vector3d& v1, double r ){
      this->x = v1.x/r;
      this->y = v1.y/r;
      this->z = v1.z/r;
    }

    void operator +=( const Vector3d& v1 ){
      this->x += v1.x;
      this->y += v1.y;
      this->z += v1.z;
    }
           
    void operator -=( const Vector3d& v1 ){
      this->x -= v1.x;
      this->y -= v1.y;
      this->z -= v1.z;
    }
          
    void operator *=( double r ){
      this->x *= r;
      this->y *= r;
      this->z *= r;
    }
          
    void operator /=( double r ){
      this->x /= r;
      this->y /= r;
      this->z /= r;
    }

    //vector addition
    friend Vector3d operator+ ( const Vector3d& v1, const Vector3d& v2){
      return Vector3d(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z); 
    }

     //vector subtraction
     friend Vector3d operator- ( const Vector3d& v1, const Vector3d& v2) {
      return Vector3d(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z); 
     }
     //unary minus
     friend Vector3d operator- ( const Vector3d& v) {
      return Vector3d(-v.x, -v.y, -v.z); 
     }
     //multiply by a scalar
     friend Vector3d operator* ( const double& r, const Vector3d& v) {
      return Vector3d( r*v.x, r*v.y, r*v.z); 
     }
     
     //multiply by a scalar
     friend Vector3d operator* ( const Vector3d& v, const double& r) {
      return Vector3d( r*v.x, r*v.y, r*v.z); 
     }
     //divide by a scalar
     friend Vector3d operator/ ( const Vector3d& v, const double& r) {
      return Vector3d( v.x/r, v.y/r, v.z/r); 
     }


    //dot product    
    friend double dotProduct (const Vector3d& v1, const Vector3d& v2){
      return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
    }

    //cross product
    friend Vector3d crossProduct (const Vector3d& v1, const Vector3d& v2){
      Vector3d result;
      
      result.x =   v1.y * v2.z - v1.z * v2.y ;
      result.y = -v1.x * v2.z + v1.z * v2.x ;
      result.z =   v1.x * v2.y - v1.y * v2.x;

      return result;
    }
    
    void normalize(){
      double len;
      
      len = length();
      x /= len ;
      y /= len;
      z /= len;
    }

    double length(){
      return sqrt(x*x + y*y + z*z);
    }

    double length2(){
      return x*x + y*y + z*z;
    }

  public:

    double x;
    double y;
    double z;
};

    
#endif //end ifndef _VECTOR3D_H_
Revision:	1443
Committed:	Fri Jul 30 14:44:10 2004 UTC (19 years, 11 months ago) by tim
File size:	4964 byte(s)
Log Message:	remove anonymous struct from Vector3d.hpp
#	Content
1	#ifndef _VECTOR3D_H_
2	#define _VECTOR3D_H_
3
4	#include <cmath>
5	#include <iostream>
6
7	using namespace std;
8
9	class Vector3d{
10
11	public:
12
13	Vector3d(){
14	this->x = double();
15	this->y = double();
16	this->z = double();
17
18	}
19
20	Vector3d( double x, double y, double z){
21	this->x = x;
22	this->y = y;
23	this->z = z;
24	}
25
26	Vector3d(double* r){
27	this->x = r[0];
28	this->y = r[1];
29	this->z = r[2];
30	}
31
32	Vector3d(const Vector3d& v1){
33	this->x = v1.x;
34	this->y = v1.y;
35	this->z = v1.z;
36	}
37
38	double& operator[](unsigned int index){
39	switch (index){
40	case 0 :
41	return x;
42
43	case 1 :
44	return y;
45
46	case 2 :
47	return z;
48
49	default:
50	cerr << index <<" is invalid index" << endl;
51	exit(1);
52	}
53	}
54
55	const double& operator[](unsigned int index) const{
56	switch (index){
57	case 0 :
58	return x;
59
60	case 1 :
61	return y;
62
63	case 2 :
64	return z;
65
66	default:
67	cerr << index <<" is invalid index" << endl;
68	exit(1);
69	}
70	}
71
72	Vector3d& operator=( const Vector3d& v1 ){
73	if(this == & v1)
74	return *this;
75
76	this->x = v1.x;
77	this->y = v1.y;
78	this->z = v1.z;
79
80	return *this;
81	}
82
83	bool operator ==( const Vector3d& v1 ){
84	return this->x == v1.x && this->y == v1.y && this->z == v1.z;
85	}
86
87	bool operator !=( const Vector3d& v1 ){
88	return this->x != v1.x \|\| this->y != v1.y \|\| this->z != v1.z;
89	}
90
91	void neg(){
92	this->x = -this->x;
93	this->y = -this->y;
94	this->z = -this->z;
95	}
96
97	void add( const Vector3d& v1 ){
98	this->x += v1.x;
99	this->y += v1.y;
100	this->z += v1.z;
101	}
102
103	void add( const Vector3d& v1, const Vector3d &v2 ){
104	this->x = v1.x + v1.x;
105	this->y = v1.y + v2.y;
106	this->z = v1.z + v2.z;
107
108	}
109
110	void sub( const Vector3d& v1 ){
111	this->x -= v1.x;
112	this->y -= v1.y;
113	this->z -= v1.z;
114	}
115
116	void sub( const Vector3d& v1, const Vector3d &v2 ){
117	this->x = v1.x - v1.x;
118	this->y = v1.y - v2.y;
119	this->z = v1.z - v2.z;
120	}
121
122	void mul( double r ){
123	this->x *= r;
124	this->y *= r;
125	this->z *= r;
126	}
127
128	void mul( double r, const Vector3d& v1 ){
129	this->x = r * v1.x;
130	this->y = r * v1.y;
131	this->z = r * v1.z;
132
133	}
134
135	void mul( const Vector3d& v1, double r ){
136	this->x = v1.x * r;
137	this->y = v1.y * r;
138	this->z = v1.z * r;
139	}
140
141	void div( double r){
142	this->x /= r;
143	this->y /= r;
144	this->z /= r;
145	}
146
147	void div( const Vector3d& v1, double r ){
148	this->x = v1.x/r;
149	this->y = v1.y/r;
150	this->z = v1.z/r;
151	}
152
153	void operator +=( const Vector3d& v1 ){
154	this->x += v1.x;
155	this->y += v1.y;
156	this->z += v1.z;
157	}
158
159	void operator -=( const Vector3d& v1 ){
160	this->x -= v1.x;
161	this->y -= v1.y;
162	this->z -= v1.z;
163	}
164
165	void operator *=( double r ){
166	this->x *= r;
167	this->y *= r;
168	this->z *= r;
169	}
170
171	void operator /=( double r ){
172	this->x /= r;
173	this->y /= r;
174	this->z /= r;
175	}
176
177	//vector addition
178	friend Vector3d operator+ ( const Vector3d& v1, const Vector3d& v2){
179	return Vector3d(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z);
180	}
181
182	//vector subtraction
183	friend Vector3d operator- ( const Vector3d& v1, const Vector3d& v2) {
184	return Vector3d(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z);
185	}
186	//unary minus
187	friend Vector3d operator- ( const Vector3d& v) {
188	return Vector3d(-v.x, -v.y, -v.z);
189	}
190	//multiply by a scalar
191	friend Vector3d operator* ( const double& r, const Vector3d& v) {
192	return Vector3d( rv.x, rv.y, r*v.z);
193	}
194
195	//multiply by a scalar
196	friend Vector3d operator* ( const Vector3d& v, const double& r) {
197	return Vector3d( rv.x, rv.y, r*v.z);
198	}
199	//divide by a scalar
200	friend Vector3d operator/ ( const Vector3d& v, const double& r) {
201	return Vector3d( v.x/r, v.y/r, v.z/r);
202	}
203
204
205	//dot product
206	friend double dotProduct (const Vector3d& v1, const Vector3d& v2){
207	return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
208	}
209
210	//cross product
211	friend Vector3d crossProduct (const Vector3d& v1, const Vector3d& v2){
212	Vector3d result;
213
214	result.x = v1.y * v2.z - v1.z * v2.y ;
215	result.y = -v1.x * v2.z + v1.z * v2.x ;
216	result.z = v1.x * v2.y - v1.y * v2.x;
217
218	return result;
219	}
220
221	void normalize(){
222	double len;
223
224	len = length();
225	x /= len ;
226	y /= len;
227	z /= len;
228	}
229
230	double length(){
231	return sqrt(xx + yy + z*z);
232	}
233
234	double length2(){
235	return xx + yy + z*z;
236	}
237
238	public:
239
240	double x;
241	double y;
242	double z;
243	};
244
245
246	#endif //end ifndef _VECTOR3D_H_