GenGeo  1.1
vector3.hh
Go to the documentation of this file.
1 
2 // //
3 // Copyright (c) 2007-2014 by The University of Queensland //
4 // Centre for Geoscience Computing //
5 // http://earth.uq.edu.au/centre-geoscience-computing //
6 // //
7 // Primary Business: Brisbane, Queensland, Australia //
8 // Licensed under the Open Software License version 3.0 //
9 // http://www.opensource.org/licenses/osl-3.0.php //
10 // //
12 
13 
14 #ifndef __VECTOR3_HH
15 #define __VECTOR3_HH
16 
17 //#include "Foundation/Matrix3.h"
18 
19 //the error...
20 /*
21 VECTOR3_INLINE VecErr::VecErr(const string& m):MError(m)
22 {
23  message.insert(0,"Vector3 ");
24 }
25 */
26 
27 // constructors
29 {
30  data[0]=0;
31  data[1]=0;
32  data[2]=0;
33 }
34 
36 {
37  data[0]=s;
38  data[1]=s;
39  data[2]=s;
40 }
41 
42 VECTOR3_INLINE Vector3::Vector3(double a,double b,double c)
43 {
44  data[0]=a;
45  data[1]=b;
46  data[2]=c;
47 }
48 
50 {
51  data[0]=rhs.data[0];
52  data[1]=rhs.data[1];
53  data[2]=rhs.data[2];
54 }
55 
56 // operators
57 
59 {
60  data[0]=rhs.data[0];
61  data[1]=rhs.data[1];
62  data[2]=rhs.data[2];
63  return *this;
64 }
65 
67 {
68  data[0]=s;
69  data[1]=s;
70  data[2]=s;
71  return *this;
72 }
73 
75 {
76  data[0]-=rhs.data[0];
77  data[1]-=rhs.data[1];
78  data[2]-=rhs.data[2];
79  return *this;
80 }
81 
83 {
84  data[0]+=rhs.data[0];
85  data[1]+=rhs.data[1];
86  data[2]+=rhs.data[2];
87  return *this;
88 }
89 
91 {
92  return Vector3(data[0]+rhs.data[0], data[1]+rhs.data[1], data[2]+rhs.data[2]);
93 }
94 
96 {
97  return Vector3(data[0]-rhs.data[0], data[1]-rhs.data[1], data[2]-rhs.data[2]);
98 }
99 
101 {
102  return Vector3( -data[0],-data[1],-data[2] );
103 }
104 
105 /*
106 VECTOR3_INLINE Vector3 Vector3::operator*(const Matrix3 &m) const
107 {
108  const double x = m(0,0)*data[0] + m(1,0)*data[1] + m(2,0)*data[2];
109  const double y = m(0,1)*data[0] + m(1,1)*data[1] + m(2,1)*data[2];
110  const double z = m(0,2)*data[0] + m(1,2)*data[1] + m(2,2)*data[2];
111 
112  return Vector3(x,y,z);
113 }
114 */
115 
116 VECTOR3_INLINE double Vector3::operator*(const Vector3& rhs) const
117 {
118  return data[0]*rhs.data[0]+data[1]*rhs.data[1]+data[2]*rhs.data[2];
119 }
120 
122 {
123  return Vector3(data[0]*s,data[1]*s,data[2]*s) ;
124 }
125 
127 {
128  data[0]*=rhs;
129  data[1]*=rhs;
130  data[2]*=rhs;
131  return *this;
132 }
133 
135 {
136  data[0] /= c;
137  data[1] /= c;
138  data[2] /= c;
139 
140  return *this;
141 }
142 
144 {
145  return Vector3(data[0]/s,data[1]/s,data[2]/s) ;
146 }
147 
149 {
150  return Vector3(data[0]+s, data[1]+s, data[2]+s) ;
151 }
152 
154 {
155  return Vector3(data[0]-s, data[1]-s, data[2]-s);
156 }
157 
158 VECTOR3_INLINE Vector3 Vector3::rotate(const Vector3 &axis, const Vector3 &axisPt) const
159 {
160  const double phi = axis.norm();
161  if (phi > 0.0)
162  {
163  const Vector3 r = *this - axisPt;
164  const Vector3 n = axis/phi;
165  const double cosPhi = cos(phi);
166  const Vector3 rotatedR =
167  r*cosPhi + n*((dot(n, r))*(1-cosPhi)) + cross(r, n)*sin(phi);
168  return rotatedR + axisPt;
169  }
170  return *this;
171 }
172 
174 {
175  data[0] += s;
176  data[1] += s;
177  data[2] += s;
178  return *this;
179 }
180 
182 {
183  data[0] -= s;
184  data[1] -= s;
185  data[2] -= s;
186  return *this;
187 }
188 
189 // vector product
190 // 9 Flops ( 6 mult, 3 sub )
192 {
193  return Vector3(lhs.data[1]*rhs.data[2]-lhs.data[2]*rhs.data[1],
194  lhs.data[2]*rhs.data[0]-lhs.data[0]*rhs.data[2],
195  lhs.data[0]*rhs.data[1]-lhs.data[1]*rhs.data[0]);
196 }
197 
198 // dot product
199 
200 VECTOR3_INLINE double dot(const Vector3& v1, const Vector3& v2)
201 {
202  return v1.data[0] * v2.data[0] +
203  v1.data[1] * v2.data[1] +
204  v1.data[2] * v2.data[2];
205 }
206 
208 {
209  return Vector3(f*rhs.data[0], f*rhs.data[1], f*rhs.data[2]);
210 }
211 
212 
213 // euclidian norm
214 // 6 Flops ( 3 mult, 2 add, 1 sqrt )
216 {
217  return sqrt(data[0]*data[0]+data[1]*data[1]+data[2]*data[2]);
218 }
219 
220 // weighted euclidian norm
221 VECTOR3_INLINE double Vector3::wnorm(double wx, double wy, double wz) const
222 {
223  double dx=data[0]/wx;
224  double dy=data[1]/wy;
225  double dz=data[2]/wz;
226 
227  return sqrt(dx*dx+dy*dy+dz*dz);
228 }
229 
230 // square of weighted euclidian norm
231 VECTOR3_INLINE double Vector3::wnorm2(double wx, double wy, double wz) const
232 {
233  double dx=data[0]/wx;
234  double dy=data[1]/wy;
235  double dz=data[2]/wz;
236 
237  return dx*dx+dy*dy+dz*dz;
238 }
239 
240 // square of the euclidian norm
241 // 5 Flops ( 3 mult, 2 add)
243 {
244  return data[0]*data[0]+data[1]*data[1]+data[2]*data[2];
245 }
246 
247 // returns unit vector in direction of the original vector
248 // 9 Flops ( 3 mult, 2 add, 3 div, 1 sqrt )
250 {
251  return (*this)/norm();
252 }
253 
254 // per element min/max
256 {
257  Vector3 res;
258  res.data[0]=v1.data[0]>v2.data[0] ? v1.data[0] : v2.data[0];
259  res.data[1]=v1.data[1]>v2.data[1] ? v1.data[1] : v2.data[1];
260  res.data[2]=v1.data[2]>v2.data[2] ? v1.data[2] : v2.data[2];
261  return res;
262 }
263 
265 {
266  Vector3 res;
267  res.data[0]=v1.data[0]<v2.data[0] ? v1.data[0] : v2.data[0];
268  res.data[1]=v1.data[1]<v2.data[1] ? v1.data[1] : v2.data[1];
269  res.data[2]=v1.data[2]<v2.data[2] ? v1.data[2] : v2.data[2];
270  return res;
271 }
272 
273 // save version, throws exception if norm()==0
274 /*
275 VECTOR3_INLINE Vector3 Vector3::unit_s() const
276 {
277  double n=norm();
278  if(n==0) throw VecErr("norm() of data[2]ero-vector");
279  Vector3 res(data[0],data[1],data[2]);
280  return res/n;
281 }
282 */
283 
285 {
286  double m = ( data[0]>data[1] ? data[0] : data[1] );
287 
288  return ( m>data[2] ? m : data[2] );
289 
290 }
291 
293 {
294  double m = ( data[0]<data[1] ? data[0] : data[1] );
295 
296  return ( m<data[2] ? m : data[2] );
297 }
298 
300 {
301  return((data[0]==V.data[0])&&(data[1]==V.data[1])&&(data[2]==V.data[2]));
302 }
303 
305 {
306  return((data[0]!=V.data[0])||(data[1]!=V.data[1])||(data[2]!=V.data[2]));
307 }
308 
309 // per component min/max
310 
312 {
313  double x=(V1.x() > V2.x()) ? V1.x() : V2.x();
314  double y=(V1.y() > V2.y()) ? V1.y() : V2.y();
315  double z=(V1.z() > V2.z()) ? V1.z() : V2.z();
316 
317  return Vector3(x,y,z);
318 }
319 
321 {
322  double x=(V1.x() < V2.x()) ? V1.x() : V2.x();
323  double y=(V1.y() < V2.y()) ? V1.y() : V2.y();
324  double z=(V1.z() < V2.z()) ? V1.z() : V2.z();
325 
326  return Vector3(x,y,z);
327 }
328 
329 // in/output
330 
331 VECTOR3_INLINE std::ostream& operator << (std::ostream& ostr,const Vector3& V)
332 {
333  const char delimiter = ' ';
334  ostr
335  << V.data[0] << delimiter
336  << V.data[1] << delimiter
337  << V.data[2];
338 
339  return ostr;
340 }
341 
342 VECTOR3_INLINE std::istream& operator >> (std::istream& istr,Vector3& V)
343 {
344  istr
345  >> V.data[0]
346  >> V.data[1]
347  >> V.data[2];
348 
349  return istr;
350 }
351 
352 #endif // __VECTOR3_HH