home *** CD-ROM | disk | FTP | other *** search
/ Hackers Magazine 57 / CdHackersMagazineNr57.iso / Software / Multimedia / k3d-setup-0.7.11.0.exe / include / k3d / k3dsdk / vector2.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-16  |  5.2 KB  |  241 lines

  1. #ifndef K3DSDK_VECTOR2_H
  2. #define K3DSDK_VECTOR2_H
  3.  
  4. // K-3D
  5. // Copyright (c) 1995-2007, Timothy M. Shead
  6. //
  7. // Contact: tshead@k-3d.com
  8. //
  9. // This library is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. //
  14. // This library is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17. // General Public License for more details.
  18. //
  19. // You should have received a copy of the GNU General Public
  20. // License along with this library; if not, write to the Free Software
  21. // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22.  
  23. /****************************************************************
  24. *
  25. * C++ Vector and Matrix Algebra routines
  26. * Author: Jean-Francois DOUE
  27. * Version 3.1 --- October 1993
  28. *
  29. ****************************************************************/
  30.  
  31. //
  32. //    From "Graphics Gems IV / Edited by Paul S. Heckbert
  33. //    Academic Press, 1994, ISBN 0-12-336156-9
  34. //    "You are free to use and modify this code in any way
  35. //    you like." (p. xv)
  36. //
  37. //    Modified by J. Nagle, March 1997
  38. //    -    All functions are inline.
  39. //    -    All functions are const-correct.
  40. //    -    All checking is via the standard "assert" macro.
  41. //
  42.  
  43. // Modified by Tim Shead for use with K-3D, January 1998
  44.  
  45. #include "almost_equal.h"
  46. #include "result.h"
  47.  
  48. #include <boost/io/ios_state.hpp>
  49.  
  50. #include <cmath>
  51. #include <iomanip>
  52.  
  53. namespace k3d
  54. {
  55.  
  56. /////////////////////////////////////////////////////////////////////////////
  57. // vector2
  58.  
  59. /// Encapsulates a direction vector in two-dimensional space
  60. class vector2
  61. {
  62. public:
  63.     /// Stores the vector values
  64.     double n[2];
  65.  
  66.     vector2()
  67.     {
  68.         n[0] = n[1] = 0.0;
  69.     }
  70.  
  71.     vector2(const double x, const double y)
  72.     {
  73.         n[0] = x;
  74.         n[1] = y;
  75.     }
  76.  
  77.     vector2& operator+=(const vector2& v)
  78.     {
  79.         n[0] += v.n[0];
  80.         n[1] += v.n[1];
  81.         return *this;
  82.     }
  83.  
  84.     vector2& operator-=(const vector2& v)
  85.     {
  86.         n[0] -= v.n[0];
  87.         n[1] -= v.n[1];
  88.         return *this;
  89.     }
  90.  
  91.     vector2& operator*=(const double d)
  92.     {
  93.         n[0] *= d;
  94.         n[1] *= d;
  95.         return *this;
  96.     }
  97.  
  98.     vector2& operator/=(const double d)
  99.     {
  100.         return_val_if_fail(d, *this);
  101.  
  102.         const double d_inv = 1./d;
  103.         n[0] *= d_inv;
  104.         n[1] *= d_inv;
  105.         return *this;
  106.     }
  107.  
  108.     double& operator[](const unsigned int i)
  109.     {
  110.         assert_warning((i == 0) || (i == 1));
  111.         return n[i];
  112.     }
  113.  
  114.     double operator[](const unsigned int i) const
  115.     {
  116.         return_val_if_fail((i == 0) || (i == 1), 0);
  117.         return n[i];
  118.     }
  119.  
  120.     /// Returns the normal length
  121.     double length() const
  122.     {
  123.         return std::sqrt(length2());
  124.     }
  125.  
  126.     /// Returns the squared normal length
  127.     double length2() const
  128.     {
  129.         return n[0] * n[0] + n[1] * n[1];
  130.     }
  131.  
  132.     friend std::ostream& operator<<(std::ostream& Stream, const vector2& RHS)
  133.     {
  134.         boost::io::ios_flags_saver stream_state(Stream);
  135.         Stream << std::setprecision(17) << RHS.n[0] << " " << RHS.n[1];
  136.         return Stream;
  137.     }
  138.  
  139.     friend std::istream& operator>>(std::istream& Stream, vector2& RHS)
  140.     {
  141.         Stream >> RHS.n[0] >> RHS.n[1];
  142.         return Stream;
  143.     }
  144. };
  145.  
  146. /// Negation
  147. inline const vector2 operator-(const vector2& v)
  148. {
  149.     return vector2(-v.n[0], -v.n[1]);
  150. }
  151.  
  152. /// Addition
  153. inline const vector2 operator+(const vector2& a, const vector2& b)
  154. {
  155.     return vector2(a.n[0] + b.n[0], a.n[1] + b.n[1]);
  156. }
  157.  
  158. /// Subtraction
  159. inline const vector2 operator-(const vector2& a, const vector2& b)
  160. {
  161.     return vector2(a.n[0] - b.n[0], a.n[1] - b.n[1]);
  162. }
  163.  
  164. /// Multiplication by a constant
  165. inline const vector2 operator*(const vector2& a, const double d)
  166. {
  167.     return vector2(a.n[0] * d, a.n[1] * d);
  168. }
  169.  
  170. /// Multiplication by a constant
  171. inline const vector2 operator*(const double d, const vector2& a)
  172. {
  173.     return vector2(a.n[0] * d, a.n[1] * d);
  174. }
  175.  
  176. /// Returns the dot product of two vectors
  177. inline const double operator*(const vector2& a, const vector2& b)
  178. {
  179.     return a.n[0] * b.n[0] + a.n[1] * b.n[1];
  180. }
  181.  
  182. /// Division by a constant
  183. inline const vector2 operator/(const vector2& a, const double d)
  184. {
  185.     return_val_if_fail(d, vector2());
  186.     return vector2(a.n[0] / d, a.n[1] / d);
  187. }
  188.  
  189. /// Equality
  190. inline const bool operator==(const vector2& a, const vector2& b)
  191. {
  192.     return a.n[0] == b.n[0] && a.n[1] == b.n[1];
  193. }
  194.  
  195. /// Inequality
  196. inline const bool operator!=(const vector2& a, const vector2& b)
  197. {
  198.     return a.n[0] != b.n[0] || a.n[1] != b.n[1];
  199. }
  200.  
  201. /// Returns the length of a vector
  202. inline const double length(const vector2& Vector)
  203. {
  204.     return Vector.length();
  205. }
  206.  
  207. /// Returns the normalized form of a vector
  208. inline const vector2 normalize(const vector2& Vector)
  209. {
  210.     const double length = Vector.length();
  211.     return_val_if_fail(length, Vector);
  212.     return Vector / length;
  213. }
  214.  
  215. /// Returns a vector perpendicular to the given vector
  216. inline const vector2 perpendicular(const vector2& Vector)
  217. {
  218.     return vector2(Vector[1], -Vector[0]);
  219. }
  220.  
  221. /// Specialization of almost_equal that tests two vector2 objects for near-equality
  222. template<>
  223. class almost_equal<vector2>
  224. {
  225.     typedef vector2 T;
  226. public:
  227.     almost_equal(const boost::uint64_t Threshold) : threshold(Threshold) { }
  228.     inline const bool operator()(const T& A, const T& B) const
  229.     {
  230.         return std::equal(A.n, A.n + 2, B.n, almost_equal<double>(threshold));
  231.     }
  232.  
  233. private:
  234.     const boost::uint64_t threshold;
  235. };
  236.  
  237. } // namespace k3d
  238.  
  239. #endif // !K3DSDK_VECTOR2_H
  240.  
  241.