src/math/Vector3.hpp

/*
 * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
 * 
 * Contact: oopse@oopse.org
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation; either version 2.1
 * of the License, or (at your option) any later version.
 * All we ask is that proper credit is given for our work, which includes
 * - but is not limited to - adding the above copyright notice to the beginning
 * of your source code files, and to any copyright notice that you may distribute
 * with programs based on this work.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

/**
 * @file Vector3.hpp
 * @author Teng Lin
 * @date 09/14/2004
 * @version 1.0
 */
 
#ifndef MATH_VECTOR3_HPP
#define MATH_VECTOR3_HPP

#include <cassert>
#include <cmath>

#include "Vector.hpp"

namespace oopse {
  
  /**
   * @class Vector3 Vector3.hpp "math/Vector3.hpp"
   * @brief 
   */
  
  template<typename Real>
  class Vector3 : public Vector<Real, 3>{
  public:
    typedef Real ElemType;
    typedef Real* ElemPoinerType;
    
    Vector3() : Vector<Real, 3>(){}
    
    /** Constructs and initializes a Vector3 from x, y, z coordinates */
    inline Vector3( double x, double y, double z) {
      data_[0] = x;
      data_[1] = y;
      data_[2] = z;
    }

    /** Constructs and initializes from an array*/
    inline Vector3(double* array) : Vector<Real, 3>(array) {}
    
    inline Vector3(const Vector<Real, 3>& v) : Vector<Real, 3>(v) {}
    
    inline Vector3<Real>& operator = (const Vector<Real, 3>& v) {
      if (this == &v) { return *this; }
      Vector<Real, 3>::operator=(v);
      return *this;
    }
    
    /**
     * Retunrs reference of the first element of Vector3.
     * @return reference of the first element of Vector3
     */
    inline Real& x() {  return data_[0];}
    
    /**
     * Retunrs the first element of Vector3.
     * @return  the first element of Vector3
     */
    inline Real x() const {  return data_[0];}
    
    /**
     * Retunrs reference of the second element of Vector3.
     * @return reference of the second element of Vector3
     */
    inline Real& y() {  return data_[1];}
    
    /**
     * Retunrs  the second element of Vector3.
     * @return c the second element of Vector3
     */
    inline Real y() const {  return data_[1];}
    
    /**
     * Retunrs reference of the third element of Vector3.
     * @return reference of the third element of Vector3
     */
    inline Real& z() {  return data_[2];}
    
    /**
     * Retunrs  the third element of Vector3.
     * @return f the third element of Vector3
     */
    inline Real z() const {  return data_[2];}
    
  };
  
  /**
   * Returns the cross product of two Vectors
   * @param v1 first vector
   * @param v2 second vector
   * @return the cross product  of v1 and v2
   * @see #vector::dot
   */
  template<typename Real>
  Vector3<Real> cross( const Vector3<Real>& v1, const Vector3<Real>& v2 ) {
    Vector3<Real> result;
    
    result.x() = v1.y() * v2.z() - v1.z() * v2.y();
    result.y() = v1.z() * v2.x() - v1.x() * v2.z();
    result.z() = v1.x() * v2.y() - v1.y() * v2.x();
    
    return result;
  }
    
  typedef Vector3<double> Vector3d;    
  
}

#endif
Revision:	151
Committed:	Mon Oct 25 22:46:19 2004 UTC (21 years ago) by tim
File size:	3770 byte(s)
Log Message:	add getArray function to RectMatrix and Vector classes
#	User	Rev	Content
1	tim	70	/*
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.
23			*
24			*/
25
26			/**
27			* @file Vector3.hpp
28			* @author Teng Lin
29			* @date 09/14/2004
30			* @version 1.0
31			*/
32
33			#ifndef MATH_VECTOR3_HPP
34			#define MATH_VECTOR3_HPP
35
36			#include <cassert>
37			#include <cmath>
38
39			#include "Vector.hpp"
40
41			namespace oopse {
42	gezelter	97
43			/**
44			* @class Vector3 Vector3.hpp "math/Vector3.hpp"
45			* @brief
46			*/
47
48			template<typename Real>
49			class Vector3 : public Vector<Real, 3>{
50			public:
51	tim	137	typedef Real ElemType;
52			typedef Real* ElemPoinerType;
53
54	gezelter	97	Vector3() : Vector<Real, 3>(){}
55
56			/** Constructs and initializes a Vector3 from x, y, z coordinates */
57			inline Vector3( double x, double y, double z) {
58			data_[0] = x;
59			data_[1] = y;
60			data_[2] = z;
61			}
62	tim	151
63			/** Constructs and initializes from an array*/
64			inline Vector3(double* array) : Vector<Real, 3>(array) {}
65	gezelter	97
66			inline Vector3(const Vector<Real, 3>& v) : Vector<Real, 3>(v) {}
67
68			inline Vector3<Real>& operator = (const Vector<Real, 3>& v) {
69			if (this == &v) { return *this; }
70			Vector<Real, 3>::operator=(v);
71			return *this;
72			}
73
74	tim	70	/**
75	gezelter	97	* Retunrs reference of the first element of Vector3.
76			* @return reference of the first element of Vector3
77	tim	70	*/
78	gezelter	97	inline Real& x() { return data_[0];}
79	tim	70
80			/**
81	gezelter	97	* Retunrs the first element of Vector3.
82			* @return the first element of Vector3
83	tim	70	*/
84	gezelter	97	inline Real x() const { return data_[0];}
85
86			/**
87			* Retunrs reference of the second element of Vector3.
88			* @return reference of the second element of Vector3
89			*/
90			inline Real& y() { return data_[1];}
91
92			/**
93			* Retunrs the second element of Vector3.
94			* @return c the second element of Vector3
95			*/
96			inline Real y() const { return data_[1];}
97
98			/**
99			* Retunrs reference of the third element of Vector3.
100			* @return reference of the third element of Vector3
101			*/
102			inline Real& z() { return data_[2];}
103
104			/**
105			* Retunrs the third element of Vector3.
106			* @return f the third element of Vector3
107			*/
108			inline Real z() const { return data_[2];}
109
110			};
111
112			/**
113			* Returns the cross product of two Vectors
114			* @param v1 first vector
115			* @param v2 second vector
116			* @return the cross product of v1 and v2
117			* @see #vector::dot
118			*/
119			template<typename Real>
120			Vector3<Real> cross( const Vector3<Real>& v1, const Vector3<Real>& v2 ) {
121			Vector3<Real> result;
122
123			result.x() = v1.y() * v2.z() - v1.z() * v2.y();
124			result.y() = v1.z() * v2.x() - v1.x() * v2.z();
125			result.z() = v1.x() * v2.y() - v1.y() * v2.x();
126
127			return result;
128			}
129
130	tim	99	typedef Vector3<double> Vector3d;
131	gezelter	97
132	tim	70	}
133
134			#endif