tcods/Vector.cpp at master · n-taka/tcods · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
#include "Vector.h"
#include <math.h>

namespace tcods
{
   Vector :: Vector( void )
   : x( 0. ),
     y( 0. ),
     z( 0. )
   {}

   Vector :: Vector( double x0,
                     double y0,
                     double z0 )
   : x( x0 ),
     y( y0 ),
     z( z0 )
   {}

   double& Vector :: operator[]( const int& index )
   {
      return ( &x )[ index ];
   }

   const double& Vector :: operator[]( const int& index ) const
   {
      return ( &x )[ index ];
   }

   Vector Vector :: operator+( const Vector& v ) const
   {
      return Vector( x + v.x,
                     y + v.y,
                     z + v.z );
   }

   Vector Vector :: operator-( const Vector& v ) const
   {
      return Vector( x - v.x,
                     y - v.y,
                     z - v.z );
   }

   Vector Vector :: operator-( void ) const
   {
      return Vector( -x,
                     -y,
                     -z );
   }

   double Vector :: operator*( const Vector& v ) const
   {
      return x*v.x +
             y*v.y +
             z*v.z ;
   }

   Vector Vector :: operator^( const Vector& v ) const
   {
      return Vector( y*v.z - z*v.y,
                     z*v.x - x*v.z,
                     x*v.y - y*v.x );
   }

   Vector Vector :: operator*( const double& c ) const
   {
      return Vector( x*c,
                     y*c,
                     z*c );
   }

   Vector operator*( const double& c, const Vector& v )
   {
      return v*c;
   }

   Vector Vector :: operator/( const double& c ) const
   {
      return (*this) * ( 1./c );
   }

   void Vector :: operator+=( const Vector& v )
   {
      x += v.x;
      y += v.y;
      z += v.z;
   }

   void Vector :: operator-=( const Vector& v )
   {
      x -= v.x;
      y -= v.y;
      z -= v.z;
   }

   void Vector :: operator*=( const double& c )
   {
      x *= c;
      y *= c;
      z *= c;
   }

   void Vector :: operator/=( const double& c )
   {
      (*this) *= ( 1./c );
   }

   double Vector :: norm( void ) const
   {
      return sqrt( norm2());
   }

   double Vector :: norm2( void ) const
   {
      return (*this) * (*this);
   }

   void Vector :: normalize( void )
   {
      (*this) /= norm();
   }

   Vector Vector :: unit( void ) const
   {
      return (*this) / norm();
   }

   std::ostream& operator << (std::ostream& os, const Vector& o)
   {
      os << "[ "
         << o.x << " "
         << o.y << " "
         << o.z
         << " ]";

      return os;
   }
}