ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/math/Vector.hpp
(Generate patch)

Comparing trunk/src/math/Vector.hpp (file contents):
Revision 246 by gezelter, Wed Jan 12 22:41:40 2005 UTC vs.
Revision 385 by tim, Tue Mar 1 20:10:14 2005 UTC

# Line 52 | Line 52
52   #include <cassert>
53   #include <cmath>
54   #include <iostream>
55 <
55 > #include <math.h>
56   namespace oopse {
57  
58      static const double epsilon = 0.000001;
# Line 87 | Line 87 | namespace oopse {
87              /** default constructor */
88              inline Vector(){
89                  for (unsigned int i = 0; i < Dim; i++)
90 <                    data_[i] = 0;
90 >                    this->data_[i] = 0;
91              }
92  
93              /** Constructs and initializes a Vector from a vector */
# Line 101 | Line 101 | namespace oopse {
101                      return *this;
102                  
103                  for (unsigned int i = 0; i < Dim; i++)            
104 <                    data_[i] = v[i];
104 >                    this->data_[i] = v[i];
105                  
106                  return *this;
107              }
# Line 109 | Line 109 | namespace oopse {
109              template<typename T>
110              inline Vector(const T& s){
111                  for (unsigned int i = 0; i < Dim; i++)
112 <                    data_[i] = s;
112 >                    this->data_[i] = s;
113              }
114              
115              /** Constructs and initializes a Vector from an array */            
116              inline Vector( Real* v) {
117                  for (unsigned int i = 0; i < Dim; i++)
118 <                    data_[i] = v[i];
118 >                    this->data_[i] = v[i];
119              }
120  
121              /**
# Line 125 | Line 125 | namespace oopse {
125               */
126              inline Real& operator[](unsigned int  i) {
127                  assert( i < Dim);
128 <                return data_[i];
128 >                return this->data_[i];
129              }
130  
131              /**
# Line 135 | Line 135 | namespace oopse {
135               */
136              inline Real& operator()(unsigned int  i) {
137                  assert( i < Dim);
138 <                return data_[i];
138 >                return this->data_[i];
139              }
140  
141              /**
# Line 145 | Line 145 | namespace oopse {
145               */
146              inline  const Real& operator[](unsigned int i) const {
147                  assert( i < Dim);
148 <                return data_[i];
148 >                return this->data_[i];
149              }
150  
151              /**
# Line 155 | Line 155 | namespace oopse {
155               */
156              inline  const Real& operator()(unsigned int i) const {
157                  assert( i < Dim);
158 <                return data_[i];
158 >                return this->data_[i];
159              }
160  
161              /** Copy the internal data to an array*/
162              void getArray(Real* array) {
163                  for (unsigned int i = 0; i < Dim; i ++) {
164 <                    array[i] = data_[i];
164 >                    array[i] = this->data_[i];
165                  }                
166              }
167  
168              /** Returns the pointer of internal array */
169              Real* getArrayPointer() {
170 <                return data_;
170 >                return this->data_;
171              }
172              
173              /**
# Line 178 | Line 178 | namespace oopse {
178               inline bool operator ==(const Vector<Real, Dim>& v) {
179  
180                  for (unsigned int i = 0; i < Dim; i ++) {
181 <                    if (!equal(data_[i], v[i])) {
181 >                    if (!equal(this->data_[i], v[i])) {
182                          return false;
183                      }
184                  }
# Line 198 | Line 198 | namespace oopse {
198              /** Negates the value of this vector in place. */          
199              inline void negate() {
200                  for (unsigned int i = 0; i < Dim; i++)
201 <                    data_[i] = -data_[i];
201 >                    this->data_[i] = -this->data_[i];
202              }
203  
204              /**
# Line 207 | Line 207 | namespace oopse {
207              */
208              inline void negate(const Vector<Real, Dim>& v1) {
209                  for (unsigned int i = 0; i < Dim; i++)
210 <                    data_[i] = -v1.data_[i];
210 >                    this->data_[i] = -v1.data_[i];
211  
212              }
213              
# Line 217 | Line 217 | namespace oopse {
217              */
218              inline void add( const Vector<Real, Dim>& v1 ) {
219                  for (unsigned int i = 0; i < Dim; i++)
220 <                    data_[i] += v1.data_[i];
220 >                    this->data_[i] += v1.data_[i];
221              }
222  
223              /**
# Line 227 | Line 227 | namespace oopse {
227              */
228              inline void add( const Vector<Real, Dim>& v1, const Vector<Real, Dim>& v2 ) {
229                  for (unsigned int i = 0; i < Dim; i++)
230 <                    data_[i] = v1.data_[i] + v2.data_[i];
230 >                    this->data_[i] = v1.data_[i] + v2.data_[i];
231              }
232  
233              /**
# Line 236 | Line 236 | namespace oopse {
236              */
237              inline void sub( const Vector<Real, Dim>& v1 ) {
238                  for (unsigned int i = 0; i < Dim; i++)
239 <                    data_[i] -= v1.data_[i];
239 >                    this->data_[i] -= v1.data_[i];
240              }
241  
242              /**
# Line 246 | Line 246 | namespace oopse {
246              */
247              inline void sub( const Vector<Real, Dim>& v1, const Vector  &v2 ){
248                  for (unsigned int i = 0; i < Dim; i++)
249 <                    data_[i] = v1.data_[i] - v2.data_[i];
249 >                    this->data_[i] = v1.data_[i] - v2.data_[i];
250              }
251  
252              /**
# Line 255 | Line 255 | namespace oopse {
255              */
256              inline void mul( Real s ) {
257                  for (unsigned int i = 0; i < Dim; i++)
258 <                   data_[i] *= s;
258 >                   this->data_[i] *= s;
259              }
260  
261              /**
# Line 266 | Line 266 | namespace oopse {
266              */
267              inline void mul( const Vector<Real, Dim>& v1, Real s) {
268                  for (unsigned int i = 0; i < Dim; i++)
269 <                    data_[i] = s * v1.data_[i];
269 >                    this->data_[i] = s * v1.data_[i];
270              }
271  
272              /**
# Line 275 | Line 275 | namespace oopse {
275              */            
276              inline void div( Real s) {
277                  for (unsigned int i = 0; i < Dim; i++)            
278 <                    data_[i] /= s;
278 >                    this->data_[i] /= s;
279              }
280  
281              /**
# Line 285 | Line 285 | namespace oopse {
285              */                        
286              inline void div( const Vector<Real, Dim>& v1, Real s ) {
287                  for (unsigned int i = 0; i < Dim; i++)
288 <                    data_[i] = v1.data_[i] / s;
288 >                    this->data_[i] = v1.data_[i] / s;
289              }
290  
291              /** @see #add */

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines