home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / graphtal / vector.c < prev    next >
C/C++ Source or Header  |  1992-10-23  |  4KB  |  206 lines
  1. /*
  2.  * Vector.C - methods for class Vector.
  3.  *
  4.  * Copyright (C) 1992, Christoph Streit (streit@iam.unibe.ch)
  5.  * All rights reserved.
  6.  *
  7.  * This software may be freely copied, modified, and redistributed
  8.  * provided that this copyright notice is preserved on all copies.
  9.  *
  10.  * You may not distribute this software, in whole or in part, as part of
  11.  * any commercial product without the express consent of the authors.
  12.  *
  13.  * There is no warranty or other guarantee of fitness of this software
  14.  * for any purpose.  It is provided solely "as is".
  15.  *
  16.  */
  17.  
  18. #include "Vector.h"
  19.  
  20. //___________________________________________________________ Vector
  21.  
  22. Vector::Vector()
  23. { v[0] = v[1] = v[2] = 0.0; }
  24.  
  25. Vector::Vector(const real x1, const real x2, const real x3) 
  26. { v[0] = x1; v[1] = x2; v[2] = x3; }
  27.  
  28. Vector::Vector(const Vector& vec)
  29. { v[0] = vec.v[0]; v[1] = vec.v[1]; v[2] = vec.v[2]; }
  30.  
  31. const Vector& Vector::operator=(const Vector& vec)
  32. {
  33.   v[0] = vec.v[0]; v[1] = vec.v[1]; v[2] = vec.v[2];
  34.   return *this;
  35. }
  36.  
  37. real& Vector::operator[](int i)
  38. { 
  39.   if (i<0 || i>2)
  40.     Error(ERR_PANIC, "Vector::operator[] index out of range");
  41.  
  42.   return v[i]; 
  43. }
  44.  
  45. real Vector::operator[](int i) const 
  46. { 
  47.   if (i<0 || i>2)
  48.     Error(ERR_PANIC, "Vector::operator[] index out of range");
  49.  
  50.   return v[i]; 
  51. }
  52.  
  53. Vector& Vector::operator+=(const Vector& vec)
  54. {
  55.   v[0] += vec[0];  v[1] += vec[1];  v[2] += vec[2];
  56.   return *this;
  57. }
  58.  
  59. Vector& Vector::operator-=(const Vector& vec)
  60. {
  61.   v[0] -= vec[0];  v[1] -= vec[1];  v[2] -= vec[2];
  62.   return *this;
  63. }
  64.  
  65. Vector& Vector::operator*=(const Vector& vec)
  66. {
  67.   static real tmp[3];
  68.  
  69.   tmp[0] = v[0]; tmp[1] = v[1]; tmp[2] = v[2]; 
  70.  
  71.   v[0] = tmp[1]*vec[2] - tmp[2]*vec[1];
  72.   v[1] = tmp[2]*vec[0] - tmp[0]*vec[2];
  73.   v[2] = tmp[0]*vec[1] - tmp[1]*vec[0];
  74.  
  75.   return *this;
  76. }
  77.  
  78. Vector& Vector::operator*=(const real x)
  79. {
  80.   v[0] *= x; v[1] *= x; v[2] *= x;
  81.   return *this;
  82. }
  83.  
  84. Vector& Vector::operator/=(const real x)
  85. {
  86.   if (equal(x, 0))
  87.     Error(ERR_PANIC, "Vector::operator/= division by zero");
  88.  
  89.   real d = 1/x;
  90.   v[0] *= d; v[1] *= d; v[2] *= d;
  91.   return *this;
  92. }
  93.  
  94. int Vector::operator==(const Vector& vec) const
  95. {
  96.   return (equal(v[0], vec[0]) && equal(v[1], vec[1]) && equal(v[2], vec[2]));
  97. }
  98.  
  99. int Vector::operator!=(const Vector& vec) const
  100. {
  101.   return !(*this == vec);
  102. }
  103.  
  104. real Vector::sqr() const
  105. {
  106.   return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
  107. }
  108.  
  109. real Vector::length() const
  110. {
  111.   return sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
  112. }
  113.  
  114. int Vector::zero() const
  115. {
  116.   return (equal(fabs(v[0]), 0) &&
  117.       equal(fabs(v[1]), 0) &&
  118.       equal(fabs(v[2]), 0));
  119. }
  120.  
  121. real Vector::distance(const Vector& vec) const
  122. {
  123.   return (*this - vec).length();
  124. }
  125.  
  126. real Vector::normalize()
  127. {
  128.   real len = length();
  129.   if (equal(len, 0))
  130.     return 0;
  131.   else {
  132.     real d = 1/len;
  133.     v[0] *= d; v[1] *= d; v[2] *= d;
  134.     return len;
  135.   }
  136. }
  137.  
  138. Vector Vector::normalized() const
  139. {
  140.   real len = length();
  141.   if (equal(len, 0)) {
  142.     Error(ERR_WARN, "Vector::normalized length is zero");
  143.     return Vector(0,0,0);
  144.   }
  145.   else
  146.     return Vector(*this / len);
  147. }
  148.  
  149. Vector Vector::operator-() const
  150. {
  151.   return Vector(-v[0], -v[1], -v[2]);
  152. }
  153.  
  154. Vector Vector::operator+(const Vector& vec) const
  155. {
  156.   return Vector(v[0] + vec[0], v[1] + vec[1], v[2] + vec[2]);
  157. }
  158.  
  159. Vector Vector::operator-(const Vector& vec) const
  160. {
  161.   return Vector(v[0] - vec[0], v[1] - vec[1], v[2] - vec[2]);
  162. }
  163.  
  164. Vector Vector::operator*(const Vector& vec) const
  165. {
  166.   return Vector(v[1]*vec[2] - v[2]*vec[1],
  167.         v[2]*vec[0] - v[0]*vec[2],
  168.         v[0]*vec[1] - v[1]*vec[0]);
  169. }
  170.  
  171. real Vector::operator^(const Vector& vec) const
  172. {
  173.   return (v[0]*vec[0] + v[1]*vec[1] + v[2]*vec[2]);
  174. }
  175.  
  176. Vector Vector::operator/(const real x) const
  177. {
  178.   if (equal(x, 0))
  179.     Error(ERR_PANIC, "Vector::operator/ division by zero");
  180.  
  181.   real d = 1/x;
  182.   return Vector(v[0]*d, v[1]*d, v[2]*d);
  183. }
  184.  
  185. Vector operator*(real x, const Vector& vec)
  186. {
  187.   return Vector(x*vec[0], x*vec[1], x*vec[2]);
  188. }
  189.  
  190. Vector operator*(const Vector& vec, real x) 
  191. {
  192.   return Vector(vec[0]*x, vec[1]*x, vec[2]*x);
  193. }
  194.  
  195. ostream& operator<<(ostream& os, const Vector& vec)
  196. {
  197.   return os << "(" 
  198.             << vec[0] << ", " << vec[1] << ", " << vec[2]
  199.         << ")";
  200. }
  201.  
  202. void Vector::swap(Vector& v1, Vector& v2)
  203. {
  204.   Vector tmp = v1; v1 = v2; v2 = tmp;
  205. }
  206.