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

Comparing trunk/OOPSE-3.0/src/math/Vector.hpp (file contents):
Revision 1603 by tim, Tue Oct 19 21:28:55 2004 UTC vs.
Revision 2069 by tim, Tue Mar 1 20:10:14 2005 UTC

# Line 1 | Line 1
1 < /*
2 < * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
3 < *
4 < * Contact: oopse@oopse.org
5 < *
6 < * This program is free software; you can redistribute it and/or
7 < * modify it under the terms of the GNU Lesser General Public License
8 < * as published by the Free Software Foundation; either version 2.1
9 < * of the License, or (at your option) any later version.
10 < * All we ask is that proper credit is given for our work, which includes
11 < * - but is not limited to - adding the above copyright notice to the beginning
12 < * of your source code files, and to any copyright notice that you may distribute
13 < * with programs based on this work.
14 < *
15 < * This program is distributed in the hope that it will be useful,
16 < * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 < * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 < * GNU Lesser General Public License for more details.
19 < *
20 < * You should have received a copy of the GNU Lesser General Public License
21 < * along with this program; if not, write to the Free Software
22 < * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
1 > /*
2 > * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3   *
4 + * The University of Notre Dame grants you ("Licensee") a
5 + * non-exclusive, royalty free, license to use, modify and
6 + * redistribute this software in source and binary code form, provided
7 + * that the following conditions are met:
8 + *
9 + * 1. Acknowledgement of the program authors must be made in any
10 + *    publication of scientific results based in part on use of the
11 + *    program.  An acceptable form of acknowledgement is citation of
12 + *    the article in which the program was described (Matthew
13 + *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 + *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 + *    Parallel Simulation Engine for Molecular Dynamics,"
16 + *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 + *
18 + * 2. Redistributions of source code must retain the above copyright
19 + *    notice, this list of conditions and the following disclaimer.
20 + *
21 + * 3. Redistributions in binary form must reproduce the above copyright
22 + *    notice, this list of conditions and the following disclaimer in the
23 + *    documentation and/or other materials provided with the
24 + *    distribution.
25 + *
26 + * This software is provided "AS IS," without a warranty of any
27 + * kind. All express or implied conditions, representations and
28 + * warranties, including any implied warranty of merchantability,
29 + * fitness for a particular purpose or non-infringement, are hereby
30 + * excluded.  The University of Notre Dame and its licensors shall not
31 + * be liable for any damages suffered by licensee as a result of
32 + * using, modifying or distributing the software or its
33 + * derivatives. In no event will the University of Notre Dame or its
34 + * licensors be liable for any lost revenue, profit or data, or for
35 + * direct, indirect, special, consequential, incidental or punitive
36 + * damages, however caused and regardless of the theory of liability,
37 + * arising out of the use of or inability to use software, even if the
38 + * University of Notre Dame has been advised of the possibility of
39 + * such damages.
40   */
41 <
41 >
42   /**
43   * @file Vector.hpp
44   * @author Teng Lin
# Line 36 | Line 52
52   #include <cassert>
53   #include <cmath>
54   #include <iostream>
55 <
55 > #include <math.h>
56   namespace oopse {
57  
58 <    const double epsilon = 0.000001;
58 >    static const double epsilon = 0.000001;
59  
60      template<typename T>
61      inline bool equal(T e1, T e2) {
# Line 65 | Line 81 | namespace oopse {
81      class Vector{
82          public:
83  
84 +            typedef Real ElemType;
85 +            typedef Real* ElemPoinerType;
86 +
87              /** default constructor */
88              inline Vector(){
89                  for (unsigned int i = 0; i < Dim; i++)
90 <                    data_[i] = 0.0;
90 >                    this->data_[i] = 0;
91              }
92  
93              /** Constructs and initializes a Vector from a vector */
# Line 82 | 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 90 | 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 106 | 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 116 | 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 126 | 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 136 | 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] = this->data_[i];
165 +                }                
166 +            }
167 +
168 +            /** Returns the pointer of internal array */
169 +            Real* getArrayPointer() {
170 +                return this->data_;
171 +            }
172 +            
173              /**
174               * Tests if this vetor is equal to other vector
175               * @return true if equal, otherwise return false
# Line 147 | 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 167 | 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 176 | 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 186 | 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 196 | 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 205 | 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 215 | 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 224 | 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 235 | 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 244 | 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 254 | 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