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 1597 by tim, Tue Oct 19 04:34:35 2004 UTC vs.
Revision 1937 by tim, Thu Jan 13 19:40:37 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 55 | Line 71 | namespace oopse {
71      inline bool equal(double e1, double e2) {
72          return fabs(e1 - e2) < epsilon;
73      }
74 +
75      
76      /**
77       * @class Vector Vector.hpp "math/Vector.hpp"
# Line 63 | Line 80 | namespace oopse {
80      template<typename Real, unsigned int Dim>
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 >                    data_[i] = 0;
91              }
92  
93              /** Constructs and initializes a Vector from a vector */
# Line 93 | Line 113 | namespace oopse {
113              }
114              
115              /** Constructs and initializes a Vector from an array */            
116 <            inline Vector( double* v) {
116 >            inline Vector( Real* v) {
117                  for (unsigned int i = 0; i < Dim; i++)
118                      data_[i] = v[i];
119              }
# Line 103 | Line 123 | namespace oopse {
123               * @return reference of ith element
124               * @param i index
125               */
126 <            inline double& operator[](unsigned int  i) {
126 >            inline Real& operator[](unsigned int  i) {
127                  assert( i < Dim);
128                  return data_[i];
129              }
# Line 113 | Line 133 | namespace oopse {
133               * @return reference of ith element
134               * @param i index
135               */
136 <            inline double& operator()(unsigned int  i) {
136 >            inline Real& operator()(unsigned int  i) {
137                  assert( i < Dim);
138                  return data_[i];
139              }
# Line 123 | Line 143 | namespace oopse {
143               * @return reference of ith element
144               * @param i index
145               */
146 <            inline  const double& operator[](unsigned int i) const {
146 >            inline  const Real& operator[](unsigned int i) const {
147                  assert( i < Dim);
148                  return data_[i];
149              }
# Line 133 | Line 153 | namespace oopse {
153               * @return reference of ith element
154               * @param i index
155               */
156 <            inline  const double& operator()(unsigned int i) const {
156 >            inline  const Real& operator()(unsigned int i) const {
157                  assert( i < Dim);
158                  return 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];
165 +                }                
166 +            }
167 +
168 +            /** Returns the pointer of internal array */
169 +            Real* getArrayPointer() {
170 +                return data_;
171 +            }
172 +            
173              /**
174               * Tests if this vetor is equal to other vector
175               * @return true if equal, otherwise return false
# Line 184 | Line 216 | namespace oopse {
216              * @param v1 the other vector
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];
221 <                }
219 >                for (unsigned int i = 0; i < Dim; i++)
220 >                    data_[i] += v1.data_[i];
221 >            }
222  
223              /**
224              * Sets the value of this vector to the sum of v1 and v2 (*this = v1 + v2).
# Line 221 | Line 253 | namespace oopse {
253              * Sets the value of this vector to the scalar multiplication of itself (*this *= s).
254              * @param s the scalar value
255              */
256 <            inline void mul( double s ) {
256 >            inline void mul( Real s ) {
257                  for (unsigned int i = 0; i < Dim; i++)
258                     data_[i] *= s;
259              }
# Line 232 | Line 264 | namespace oopse {
264              * @param v1 the vector            
265              * @param s the scalar value
266              */
267 <            inline void mul( const Vector<Real, Dim>& v1, double s) {
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];
270              }
# Line 241 | Line 273 | namespace oopse {
273              * Sets the value of this vector to the scalar division of itself  (*this /= s ).
274              * @param s the scalar value
275              */            
276 <            inline void div( double s) {
276 >            inline void div( Real s) {
277                  for (unsigned int i = 0; i < Dim; i++)            
278                      data_[i] /= s;
279              }
# Line 251 | Line 283 | namespace oopse {
283              * @param v1 the source vector
284              * @param s the scalar value
285              */                        
286 <            inline void div( const Vector<Real, Dim>& v1, double s ) {
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;
289              }
# Line 269 | Line 301 | namespace oopse {
301              }
302  
303              /** @see #mul */
304 <            inline Vector<Real, Dim>& operator *=( double s) {
304 >            inline Vector<Real, Dim>& operator *=( Real s) {
305                  mul(s);
306                  return *this;
307              }
308  
309              /** @see #div */
310 <            inline Vector<Real, Dim>& operator /=( double s ) {
310 >            inline Vector<Real, Dim>& operator /=( Real s ) {
311                  div(s);
312                  return *this;
313              }
# Line 284 | Line 316 | namespace oopse {
316               * Returns the length of this vector.
317               * @return the length of this vector
318               */
319 <             inline double length() {
319 >             inline Real length() {
320                  return sqrt(lengthSquare());  
321              }
322              
# Line 292 | Line 324 | namespace oopse {
324               * Returns the squared length of this vector.
325               * @return the squared length of this vector
326               */
327 <             inline double lengthSquare() {
327 >             inline Real lengthSquare() {
328                  return dot(*this, *this);
329              }
330              
331              /** Normalizes this vector in place */
332              inline void normalize() {
333 <                double len;
333 >                Real len;
334  
335                  len = length();
336                  
# Line 317 | Line 349 | namespace oopse {
349              }          
350              
351          protected:
352 <            double data_[Dim];
352 >            Real data_[Dim];
353          
354      };
355  
# Line 363 | Line 395 | namespace oopse {
395       * @param s the scalar value
396       */
397      template<typename Real, unsigned int Dim>                
398 <    Vector<Real, Dim> operator * ( const Vector<Real, Dim>& v1, double s) {      
398 >    Vector<Real, Dim> operator * ( const Vector<Real, Dim>& v1, Real s) {      
399          Vector<Real, Dim> result;
400          result.mul(v1,s);
401          return result;          
# Line 376 | Line 408 | namespace oopse {
408       * @param v1 the source vector
409       */  
410      template<typename Real, unsigned int Dim>
411 <    Vector<Real, Dim> operator * ( double s, const Vector<Real, Dim>& v1 ) {
411 >    Vector<Real, Dim> operator * ( Real s, const Vector<Real, Dim>& v1 ) {
412          Vector<Real, Dim> result;
413          result.mul(v1, s);
414          return result;          
# Line 389 | Line 421 | namespace oopse {
421       * @param s the scalar value
422       */
423      template<typename Real, unsigned int Dim>    
424 <    Vector<Real, Dim> operator / ( const Vector<Real, Dim>& v1, double s) {      
424 >    Vector<Real, Dim> operator / ( const Vector<Real, Dim>& v1, Real s) {      
425          Vector<Real, Dim> result;
426          result.div( v1,s);
427          return result;          
# Line 407 | Line 439 | namespace oopse {
439          tmp = 0;
440  
441          for (unsigned int i = 0; i < Dim; i++)
442 <            tmp += v1[i] + v2[i];
442 >            tmp += v1[i] * v2[i];
443  
444          return tmp;
445      }
# Line 442 | Line 474 | namespace oopse {
474      template<typename Real, unsigned int Dim>
475      std::ostream &operator<< ( std::ostream& o, const Vector<Real, Dim>& v) {
476  
477 <        o << "[" << v[0] << ", " << v[1] << ", " << v[2] << "]" << endl;
477 >        o << "[ ";
478 >        
479 >        for (unsigned int i = 0 ; i< Dim; i++) {
480 >            o << v[i];
481 >
482 >            if (i  != Dim -1) {
483 >                o<< ", ";
484 >            }
485 >        }
486 >
487 >        o << " ]";
488          return o;        
489      }
490      

Diff Legend

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