Branch data Line data Source code
1 : : //- Class: CubitVector
2 : : //-
3 : : //- Description: This file defines the CubitVector class which is a
4 : : //- standard three-dimensional vector. All relevant arithmetic
5 : : //- operators are overloaded so CubitVectors can be used similar to
6 : : //- built-in types.
7 : : //-
8 : : //- Owner: Greg Sjaardema
9 : : //- Checked by: Randy Lober, January 94
10 : : //- Version: $Id:
11 : :
12 : : #ifndef CUBITVECTOR_HPP
13 : : #define CUBITVECTOR_HPP
14 : :
15 : : #include "CubitDefines.h"
16 : : #include "CubitVectorStruct.h"
17 : : #include "CGMUtilConfigure.h"
18 : :
19 : : class CubitVector;
20 : : typedef void ( CubitVector::*transform_function )( double gamma,
21 : : double gamma2);
22 : : // a pointer to some function that transforms the point,
23 : : // taking a double parameter. e.g. blow_out, rotate, and scale_angle
24 : :
25 : : class CUBIT_UTIL_EXPORT CubitVector
26 : : {
27 : : public:
28 : :
29 : : //- Heading: Constructors and Destructor
30 : : CubitVector(); //- Default constructor.
31 : :
32 : : explicit CubitVector(const double x, const double y, const double z);
33 : : //- Constructor: create vector from three components
34 : :
35 : : explicit CubitVector( const double xyz[3] );
36 : : //- Constructor: create vector from tuple
37 : :
38 : : explicit CubitVector (const CubitVector& tail, const CubitVector& head);
39 : : //- Constructor for a CubitVector starting at tail and pointing
40 : : //- to head.
41 : :
42 : : CubitVector(const CubitVector& copy_from); //- Copy Constructor
43 : :
44 : : explicit CubitVector(const CubitVectorStruct& from);
45 : :
46 : : //- Heading: Set and Inquire Functions
47 : : void set(const double x, const double y, const double z);
48 : : //- Change vector components to {x}, {y}, and {z}
49 : :
50 : : void set( const double xyz[3] );
51 : : //- Change vector components to xyz[0], xyz[1], xyz[2]
52 : :
53 : : void set(const CubitVector& tail, const CubitVector& head);
54 : : //- Change vector to go from tail to head.
55 : :
56 : : void set(const CubitVector& to_copy);
57 : : //- Same as i.=(const CubitVector&)
58 : :
59 : : double x() const; //- Return x component of vector
60 : :
61 : : double y() const; //- Return y component of vector
62 : :
63 : : double z() const; //- Return z component of vector
64 : :
65 : : double& x();
66 : : double& y();
67 : : double& z();
68 : :
69 : : void get_xyz( double &x, double &y, double &z ) const; //- Get x, y, z components
70 : : void get_xyz( double xyz[3] ) const; //- Get xyz tuple
71 : :
72 : : double &r(); //- Return r component of vector, if (r,theta) format
73 : :
74 : : double &theta(); //- Return theta component of vector, if (r,theta) format
75 : :
76 : : void x( const double x ); //- Set x component of vector
77 : :
78 : : void y( const double y ); //- Set y component of vector
79 : :
80 : : void z( const double z ); //- Set z component of vector
81 : :
82 : : void r( const double x ); //- Set r component of vector, if (r,theta) format
83 : :
84 : : void theta( const double y ); //- Set theta component of vector, if (r,theta) format
85 : :
86 : : void xy_to_rtheta();
87 : : //- convert from cartesian to polar coordinates, just 2d for now
88 : : //- theta is in [0,2 PI)
89 : :
90 : : void rtheta_to_xy();
91 : : //- convert from polar to cartesian coordinates, just 2d for now
92 : :
93 : : void scale_angle(double gamma, double );
94 : : //- tranform_function.
95 : : //- transform (x,y) to (r,theta) to (r,gamma*theta) to (x',y')
96 : : //- plus some additional scaling so long chords won't cross short ones
97 : :
98 : : void blow_out(double gamma, double gamma2 = 0.0);
99 : : //- transform_function
100 : : //- blow points radially away from the origin,
101 : :
102 : : void rotate(double angle, double );
103 : : //- transform function.
104 : : //- transform (x,y) to (r,theta) to (r,theta+angle) to (x',y')
105 : :
106 : : void project_to_plane( const CubitVector &planenormal );
107 : : //- project this vector onto a plane.
108 : :
109 : : void project_to_line_segment( const CubitVector &pt0, const CubitVector &pt1 );
110 : : //- project this vector onto a line segment.
111 : :
112 : : void reflect_about_xaxis(double dummy, double );
113 : : //- dummy argument to make it a transform function
114 : :
115 : : double normalize();
116 : : //- Normalize (set magnitude equal to 1) vector - return the magnitude
117 : :
118 : : CubitVector& length(const double new_length);
119 : : //- Change length of vector to {new_length}. Can be used to move a
120 : : //- location a specified distance from the origin in the current
121 : : //- orientation.
122 : :
123 : : double length() const;
124 : : //- Calculate the length of the vector.
125 : : //- Use {length_squared()} if only comparing lengths, not adding.
126 : :
127 : : double distance_between(const CubitVector& test_vector) const;
128 : : //- Calculate the distance from the head of one vector
129 : : // to the head of the test_vector.
130 : :
131 : : double distance_between_squared(const CubitVector& test_vector) const;
132 : : //- Calculate the distance squared from the head of one vector
133 : : // to the head of the test_vector.
134 : :
135 : : double distance_from_infinite_line(const CubitVector& point_on_line,
136 : : const CubitVector& line_direction) const;
137 : : //- Calculate the minimum distance between the head of this vector and a
138 : : // line of infinite length.
139 : :
140 : : double distance_from_infinite_line_squared(const CubitVector& point_on_line,
141 : : const CubitVector& line_direction) const;
142 : : //- Calculate the square of the minimum distance between the head of this
143 : : // vector and a line of infinite length.
144 : :
145 : : double length_squared() const;
146 : : //- Calculate the squared length of the vector.
147 : : //- Faster than {length()} since it eliminates the square root if
148 : : //- only comparing other lengths.
149 : :
150 : : double interior_angle(const CubitVector &otherVector) const;
151 : : //- Calculate the interior angle: acos((a%b)/(|a||b|))
152 : : //- Returns angle in degrees.
153 : :
154 : : static bool colinear( const CubitVector &p0,
155 : : const CubitVector &p1,
156 : : const CubitVector &p2 );
157 : : //- determine if 3 points are colinear.
158 : :
159 : : static CubitVector normal( const CubitVector &p0,
160 : : const CubitVector &p1,
161 : : const CubitVector &p2 );
162 : : //- normal given 3 positions.
163 : :
164 : : static bool barycentric_coordinates( const CubitVector &v1,
165 : : const CubitVector &v2,
166 : : const CubitVector &v3,
167 : : const CubitVector &point,
168 : : double &coord_A,
169 : : double &coord_B,
170 : : double &coord_C );
171 : :
172 : : double vector_angle_quick(const CubitVector& vec1, const CubitVector& vec2);
173 : : //- Calculate the interior angle between the projections of
174 : : //- {vec1} and {vec2} onto the plane defined by the {this} vector.
175 : : //- The angle returned is the right-handed angle around the {this}
176 : : //- vector from {vec1} to {vec2}. Angle is in radians.
177 : :
178 : : double vector_angle( const CubitVector &vector1,
179 : : const CubitVector &vector2) const;
180 : : //- Compute the angle between the projections of {vector1} and {vector2}
181 : : //- onto the plane defined by *this. The angle is the
182 : : //- right-hand angle, in radians, about *this from {vector1} to {vector2}.
183 : :
184 : : void perpendicular_z();
185 : : //- Transform this vector to a perpendicular one, leaving
186 : : //- z-component alone. Rotates clockwise about the z-axis by pi/2.
187 : :
188 : : void print_me();
189 : : //- Prints out the coordinates of this vector.
190 : :
191 : : void orthogonal_vectors( CubitVector &vector2, CubitVector &vector3 ) const;
192 : : //- Finds 2 (arbitrary) vectors that are orthogonal to this one
193 : :
194 : : void next_point( const CubitVector &direction, double distance,
195 : : CubitVector& out_point ) const;
196 : : //- Finds the next point in space based on *this* point (starting point),
197 : : //- a direction and the distance to extend in the direction. The
198 : : //- direction vector need not be a unit vector. The out_point can be
199 : : //- "*this" (i.e., modify point in place).
200 : :
201 : : CubitBoolean about_equal( const CubitVector &w,
202 : : const double relative_tolerance = 1.0e-6,
203 : : const double absolute_tolerance = 1.0e-6 ) const;
204 : : // Return true if vectors are equal within either relative tolerance
205 : : // or absolute tolerance.
206 : : //
207 : : // More specifically:
208 : : // Return true if the magnitude of the difference is less than
209 : : // 1. absolute_tolerance,
210 : : // OR
211 : : // 2. relative_tolerance times the magnitude of the vectors
212 : : //
213 : : // E.g.
214 : : // if v = <1, 1.0e-7, 0>, w = <1, -1.0e-7, 0> and relative_tol = 1.0e-6,
215 : : // then return true.
216 : :
217 : : CubitBoolean within_tolerance(const CubitVector &vectorPtr2,
218 : : double tolerance) const;
219 : : //- Compare two vectors to see if they are spatially equal.
220 : : // Return TRUE if difference in x, y, and z are all within tolerance.
221 : :
222 : : CubitBoolean within_scaled_tolerance(const CubitVector &v2, double tol) const;
223 : : // Return true if vectors are within_tolerance() or if, for each coord,
224 : : // the ratio of the two vector's coords differs no more than tol from 1.0.
225 : : // Can be used to see if two vectors are equal up to a certain number of
226 : : // significant digits. For example, passing in a tolerance of 1e-6 will
227 : : // return true if the two vectors are equal with 6 significant digits.
228 : :
229 : : //- Heading: Operator Overloads *****************************
230 : : CubitVector& operator+=(const CubitVector &vec);
231 : : //- Compound Assignment: addition: {this = this + vec}
232 : :
233 : : CubitVector& operator-=(const CubitVector &vec);
234 : : //- Compound Assignment: subtraction: {this = this - vec}
235 : :
236 : : CubitVector& operator*=(const CubitVector &vec);
237 : : //- Compound Assignment: cross product: {this = this * vec},
238 : : //- non-commutative
239 : :
240 : : CubitVector& operator*=(const double scalar);
241 : : //- Compound Assignment: multiplication: {this = this * scalar}
242 : :
243 : : CubitVector& operator/=(const double scalar);
244 : : //- Compound Assignment: division: {this = this / scalar}
245 : :
246 : : CubitVector operator-() const;
247 : : //- unary negation.
248 : :
249 : : double operator[](int i) const;
250 : : //- return the ith value of the vector (x, y, z)
251 : :
252 : : friend CubitVector operator~(const CubitVector &vec);
253 : : //- normalize. Returns a new vector which is a copy of {vec},
254 : : //- scaled such that {|vec|=1}. Uses overloaded bitwise NOT operator.
255 : :
256 : : friend CubitVector operator+(const CubitVector &v1,
257 : : const CubitVector &v2);
258 : : //- vector addition
259 : :
260 : : friend CubitVector operator-(const CubitVector &v1,
261 : : const CubitVector &v2);
262 : : //- vector subtraction
263 : :
264 : : friend CubitVector operator*(const CubitVector &v1,
265 : : const CubitVector &v2);
266 : : //- vector cross product, non-commutative
267 : :
268 : : friend CubitVector operator*(const CubitVector &v1, const double sclr);
269 : : //- vector * scalar
270 : :
271 : : friend CubitVector operator*(const double sclr, const CubitVector &v1);
272 : : //- scalar * vector
273 : :
274 : : friend double operator%(const CubitVector &v1, const CubitVector &v2);
275 : : //- dot product
276 : :
277 : : friend CubitVector operator/(const CubitVector &v1, const double sclr);
278 : : //- vector / scalar
279 : :
280 : : friend int operator==(const CubitVector &v1, const CubitVector &v2);
281 : : //- Equality operator
282 : :
283 : : friend int operator!=(const CubitVector &v1, const CubitVector &v2);
284 : : //- Inequality operator
285 : :
286 : : friend CubitVector interpolate(const double param, const CubitVector &v1,
287 : : const CubitVector &v2);
288 : : //- Interpolate between two vectors. Returns (1-param)*v1 + param*v2
289 : :
290 : : CubitVector &operator=(const CubitVectorStruct &from);
291 : :
292 : : operator CubitVectorStruct()
293 : : {
294 : : CubitVectorStruct to = {xVal, yVal, zVal};
295 : : return to;
296 : : }
297 : :
298 : : CubitVector &operator=(const CubitVector& from);
299 : :
300 : : private:
301 : :
302 : : double xVal; //- x component of vector.
303 : : double yVal; //- y component of vector.
304 : : double zVal; //- z component of vector.
305 : :
306 : : static bool attempt_barycentric_coordinates_adjustment( const CubitVector &v1,
307 : : const CubitVector &v2,
308 : : const CubitVector &v3,
309 : : const CubitVector &point,
310 : : double &coord_A,
311 : : double &coord_B,
312 : : double &coord_C );
313 : : static bool private_barycentric_coordinates( bool adjust_on_fail,
314 : : const CubitVector &v1,
315 : : const CubitVector &v2,
316 : : const CubitVector &v3,
317 : : const CubitVector &point,
318 : : double &coord_A,
319 : : double &coord_B,
320 : : double &coord_C );
321 : :
322 : : };
323 : :
324 : : CUBIT_UTIL_EXPORT CubitVector vectorRotate(const double angle,
325 : : const CubitVector &normalAxis,
326 : : const CubitVector &referenceAxis);
327 : : //- A new coordinate system is created with the xy plane corresponding
328 : : //- to the plane normal to {normalAxis}, and the x axis corresponding to
329 : : //- the projection of {referenceAxis} onto the normal plane. The normal
330 : : //- plane is the tangent plane at the root point. A unit vector is
331 : : //- constructed along the local x axis and then rotated by the given
332 : : //- ccw angle to form the new point. The new point, then is a unit
333 : : //- distance from the global origin in the tangent plane.
334 : : //- {angle} is in radians.
335 : :
336 : 4606890 : inline double CubitVector::x() const
337 : 4606890 : { return xVal; }
338 : 4564665 : inline double CubitVector::y() const
339 : 4564665 : { return yVal; }
340 : 4562290 : inline double CubitVector::z() const
341 : 4562290 : { return zVal; }
342 : 275088 : inline double& CubitVector::x()
343 : 275088 : { return xVal; }
344 : 268774 : inline double& CubitVector::y()
345 : 268774 : { return yVal; }
346 : 262163 : inline double& CubitVector::z()
347 : 262163 : { return zVal; }
348 : 0 : inline void CubitVector::get_xyz(double xyz[3]) const
349 : : {
350 : 0 : xyz[0] = xVal;
351 : 0 : xyz[1] = yVal;
352 : 0 : xyz[2] = zVal;
353 : 0 : }
354 : 32 : inline void CubitVector::get_xyz(double &xOut, double &yOut, double &zOut) const
355 : : {
356 : 32 : xOut = xVal;
357 : 32 : yOut = yVal;
358 : 32 : zOut = zVal;
359 : 32 : }
360 : 0 : inline double &CubitVector::r()
361 : 0 : { return xVal; }
362 : 0 : inline double &CubitVector::theta()
363 : 0 : { return yVal; }
364 : 526883 : inline void CubitVector::x( const double xIn )
365 : 526883 : { xVal = xIn; }
366 : 526543 : inline void CubitVector::y( const double yIn )
367 : 526543 : { yVal = yIn; }
368 : 526687 : inline void CubitVector::z( const double zIn )
369 : 526687 : { zVal = zIn; }
370 : 0 : inline void CubitVector::r( const double xIn )
371 : 0 : { xVal = xIn; }
372 : 0 : inline void CubitVector::theta( const double yIn )
373 : 0 : { yVal = yIn; }
374 : 6031 : inline CubitVector& CubitVector::operator+=(const CubitVector &v)
375 : : {
376 : 6031 : xVal += v.xVal;
377 : 6031 : yVal += v.yVal;
378 : 6031 : zVal += v.zVal;
379 : 6031 : return *this;
380 : : }
381 : :
382 : 88 : inline CubitVector& CubitVector::operator-=(const CubitVector &v)
383 : : {
384 : 88 : xVal -= v.xVal;
385 : 88 : yVal -= v.yVal;
386 : 88 : zVal -= v.zVal;
387 : 88 : return *this;
388 : : }
389 : :
390 : 16350 : inline CubitVector& CubitVector::operator*=(const CubitVector &v)
391 : : {
392 : : double xcross, ycross, zcross;
393 : 16350 : xcross = yVal * v.zVal - zVal * v.yVal;
394 : 16350 : ycross = zVal * v.xVal - xVal * v.zVal;
395 : 16350 : zcross = xVal * v.yVal - yVal * v.xVal;
396 : 16350 : xVal = xcross;
397 : 16350 : yVal = ycross;
398 : 16350 : zVal = zcross;
399 : 16350 : return *this;
400 : : }
401 : :
402 : 348059 : inline CubitVector::CubitVector(const CubitVector& copy_from)
403 : 348059 : : xVal(copy_from.xVal), yVal(copy_from.yVal), zVal(copy_from.zVal)
404 : 348059 : {}
405 : :
406 : 372206 : inline CubitVector::CubitVector()
407 : 372206 : : xVal(0), yVal(0), zVal(0)
408 : 372206 : {}
409 : :
410 : 16632 : inline CubitVector::CubitVector (const CubitVector& tail,
411 : : const CubitVector& head)
412 : 16632 : : xVal(head.xVal - tail.xVal),
413 : 16632 : yVal(head.yVal - tail.yVal),
414 : 33264 : zVal(head.zVal - tail.zVal)
415 : 16632 : {}
416 : :
417 : 398156 : inline CubitVector::CubitVector(const double xIn,
418 : : const double yIn,
419 : : const double zIn)
420 : 398156 : : xVal(xIn), yVal(yIn), zVal(zIn)
421 : 398156 : {}
422 : :
423 : 0 : inline CubitVector::CubitVector(const double xyz[3])
424 : 0 : : xVal(xyz[0]), yVal(xyz[1]), zVal(xyz[2])
425 : 0 : {}
426 : :
427 : : // This sets the vector to be perpendicular to it's current direction.
428 : : // NOTE:
429 : : // This is a 2D function. It only works in the XY Plane.
430 : : inline void CubitVector::perpendicular_z()
431 : : {
432 : : double temp = xVal;
433 : : x( yVal );
434 : : y( -temp );
435 : : }
436 : :
437 : 48209 : inline void CubitVector::set(const double xIn,
438 : : const double yIn,
439 : : const double zIn)
440 : : {
441 : 48209 : xVal = xIn;
442 : 48209 : yVal = yIn;
443 : 48209 : zVal = zIn;
444 : 48209 : }
445 : :
446 : 0 : inline void CubitVector::set(const double xyz[3])
447 : : {
448 : 0 : xVal = xyz[0];
449 : 0 : yVal = xyz[1];
450 : 0 : zVal = xyz[2];
451 : 0 : }
452 : :
453 : : inline void CubitVector::set(const CubitVector& tail,
454 : : const CubitVector& head)
455 : : {
456 : : xVal = head.xVal - tail.xVal;
457 : : yVal = head.yVal - tail.yVal;
458 : : zVal = head.zVal - tail.zVal;
459 : : }
460 : :
461 : 187283 : inline CubitVector& CubitVector::operator=(const CubitVector &from)
462 : : {
463 : 187283 : xVal = from.xVal;
464 : 187283 : yVal = from.yVal;
465 : 187283 : zVal = from.zVal;
466 : 187283 : return *this;
467 : : }
468 : :
469 : 0 : inline void CubitVector::set(const CubitVector& to_copy)
470 : : {
471 : 0 : *this = to_copy;
472 : 0 : }
473 : :
474 : : // Scale all values by scalar.
475 : 32453 : inline CubitVector& CubitVector::operator*=(const double scalar)
476 : : {
477 : 32453 : xVal *= scalar;
478 : 32453 : yVal *= scalar;
479 : 32453 : zVal *= scalar;
480 : 32453 : return *this;
481 : : }
482 : :
483 : : // Scales all values by 1/scalar
484 : 9286 : inline CubitVector& CubitVector::operator/=(const double scalar)
485 : : {
486 [ - + ]: 9286 : if(scalar == 0)
487 : 0 : throw ("Cannot divide by zero.");
488 : : //assert (scalar != 0);
489 : 9286 : xVal /= scalar;
490 : 9286 : yVal /= scalar;
491 : 9286 : zVal /= scalar;
492 : 9286 : return *this;
493 : : }
494 : :
495 : : inline CubitVector& CubitVector::operator=(const CubitVectorStruct &from)
496 : : {
497 : : xVal = from.xVal;
498 : : yVal = from.yVal;
499 : : zVal = from.zVal;
500 : : return *this;
501 : : }
502 : :
503 : : inline CubitVector::CubitVector(const CubitVectorStruct &from)
504 : : {
505 : : xVal = from.xVal;
506 : : yVal = from.yVal;
507 : : zVal = from.zVal;
508 : : }
509 : :
510 : : // Returns the normalized 'this'.
511 : 55 : inline CubitVector operator~(const CubitVector &vec)
512 : : {
513 : 110 : double mag = sqrt(vec.xVal*vec.xVal +
514 : 55 : vec.yVal*vec.yVal +
515 : 55 : vec.zVal*vec.zVal);
516 : :
517 : 55 : CubitVector temp = vec;
518 [ + - ]: 55 : if (mag != 0.0)
519 : : {
520 : 55 : temp /= mag;
521 : : }
522 : 55 : return temp;
523 : : }
524 : :
525 : : // Unary minus. Negates all values in vector.
526 : 1785 : inline CubitVector CubitVector::operator-() const
527 : : {
528 : 1785 : return CubitVector(-xVal, -yVal, -zVal);
529 : : }
530 : :
531 : 0 : inline double CubitVector::operator[](int i) const
532 : : {
533 [ # # ][ # # ]: 0 : if(i < 0 || i > 2)
534 : 0 : throw ("Index Out of Bounds");
535 : : //assert(i > -1 && i < 3);
536 [ # # ]: 0 : if (i == 0) return xVal;
537 [ # # ]: 0 : else if (i == 1) return yVal;
538 : 0 : else return zVal;
539 : : }
540 : :
541 : 100514 : inline CubitVector operator+(const CubitVector &vector1,
542 : : const CubitVector &vector2)
543 : : {
544 : 100514 : double xv = vector1.xVal + vector2.xVal;
545 : 100514 : double yv = vector1.yVal + vector2.yVal;
546 : 100514 : double zv = vector1.zVal + vector2.zVal;
547 : 100514 : return CubitVector(xv,yv,zv);
548 : : // return CubitVector(vector1) += vector2;
549 : : }
550 : :
551 : 174196 : inline CubitVector operator-(const CubitVector &vector1,
552 : : const CubitVector &vector2)
553 : : {
554 : 174196 : double xv = vector1.xVal - vector2.xVal;
555 : 174196 : double yv = vector1.yVal - vector2.yVal;
556 : 174196 : double zv = vector1.zVal - vector2.zVal;
557 : 174196 : return CubitVector(xv,yv,zv);
558 : : // return CubitVector(vector1) -= vector2;
559 : : }
560 : :
561 : : // Cross products.
562 : : // vector1 cross vector2
563 : 15822 : inline CubitVector operator*(const CubitVector &vector1,
564 : : const CubitVector &vector2)
565 : : {
566 [ + - ][ + - ]: 15822 : return CubitVector(vector1) *= vector2;
567 : : }
568 : :
569 : : // Returns a scaled vector.
570 : 66 : inline CubitVector operator*(const CubitVector &vector1,
571 : : const double scalar)
572 : : {
573 [ + - ][ + - ]: 66 : return CubitVector(vector1) *= scalar;
574 : : }
575 : :
576 : : // Returns a scaled vector
577 : 32263 : inline CubitVector operator*(const double scalar,
578 : : const CubitVector &vector1)
579 : : {
580 [ + - ][ + - ]: 32263 : return CubitVector(vector1) *= scalar;
581 : : }
582 : :
583 : : // Returns a vector scaled by 1/scalar
584 : 8307 : inline CubitVector operator/(const CubitVector &vector1,
585 : : const double scalar)
586 : : {
587 [ + - ][ + - ]: 8307 : return CubitVector(vector1) /= scalar;
588 : : }
589 : :
590 : 1046 : inline int operator==(const CubitVector &v1, const CubitVector &v2)
591 : : {
592 [ + - ][ + - ]: 1046 : return (v1.xVal == v2.xVal && v1.yVal == v2.yVal && v1.zVal == v2.zVal);
[ + - ]
593 : : }
594 : :
595 : 0 : inline int operator!=(const CubitVector &v1, const CubitVector &v2)
596 : : {
597 [ # # ][ # # ]: 0 : return (v1.xVal != v2.xVal || v1.yVal != v2.yVal || v1.zVal != v2.zVal);
[ # # ]
598 : : }
599 : :
600 : 182408 : inline double CubitVector::length_squared() const
601 : : {
602 : 182408 : return( xVal*xVal + yVal*yVal + zVal*zVal );
603 : : }
604 : :
605 : 48104 : inline double CubitVector::length() const
606 : : {
607 : 48104 : return( sqrt(xVal*xVal + yVal*yVal + zVal*zVal) );
608 : : }
609 : :
610 : 26723 : inline double CubitVector::normalize()
611 : : {
612 : 26723 : double mag = length();
613 [ + - ]: 26723 : if (mag != 0)
614 : : {
615 : 26723 : xVal = xVal / mag;
616 : 26723 : yVal = yVal / mag;
617 : 26723 : zVal = zVal / mag;
618 : : }
619 : 26723 : return mag;
620 : : }
621 : :
622 : :
623 : : // Dot Product.
624 : 22489 : inline double operator%(const CubitVector &vector1,
625 : : const CubitVector &vector2)
626 : : {
627 : 44978 : return( vector1.xVal * vector2.xVal +
628 : 22489 : vector1.yVal * vector2.yVal +
629 : 22489 : vector1.zVal * vector2.zVal );
630 : : }
631 : :
632 : : // Interpolate between two vectors.
633 : : // Returns (1-param)*v1 + param*v2
634 : : inline CubitVector interpolate(const double param, const CubitVector &v1,
635 : : const CubitVector &v2)
636 : : {
637 : : CubitVector temp = (1.0 - param) * v1;
638 : : temp += param * v2;
639 : : return temp;
640 : : }
641 : :
642 : : inline CubitVector CubitVector::normal( const CubitVector &p0,
643 : : const CubitVector &p1,
644 : : const CubitVector &p2 )
645 : : {
646 : : CubitVector edge0( p0, p1 );
647 : : CubitVector edge1( p0, p2 );
648 : :
649 : : return edge0 * edge1; // not normalized.
650 : : }
651 : :
652 : : #endif
653 : :
|
