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:

            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;
            }

            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 double& x() {  return data_[0];}

            /**
             * Retunrs the first element of Vector3.
             * @return  the first element of Vector3
             */
            inline double x() const {  return data_[0];}

            /**
             * Retunrs reference of the second element of Vector3.
             * @return reference of the second element of Vector3
             */
            inline double& y() {  return data_[1];}

            /**
             * Retunrs  the second element of Vector3.
             * @return c the second element of Vector3
             */
            inline double y() const {  return data_[1];}

            /**
             * Retunrs reference of the third element of Vector3.
             * @return reference of the third element of Vector3
             */
            inline double& z() {  return data_[2];}

            /**
             * Retunrs  the third element of Vector3.
             * @return f the third element of Vector3
             */
            inline double 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;
    }
        
}


#endif
Revision:	70
Committed:	Wed Oct 13 06:51:09 2004 UTC (21 years ago) by tim
File size:	3926 byte(s)
Log Message:	refactory vector and matrix classes
#	Content
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.
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
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
52	Vector3() : Vector<Real, 3>(){}
53
54	/** Constructs and initializes a Vector3 from x, y, z coordinates */
55	inline Vector3( double x, double y, double z) {
56	data_[0] = x;
57	data_[1] = y;
58	data_[2] = z;
59	}
60
61	inline Vector3(const Vector<Real, 3>& v) : Vector<Real, 3>(v) {}
62
63	inline Vector3<Real>& operator = (const Vector<Real, 3>& v) {
64	if (this == &v) { return *this; }
65	Vector<Real, 3>::operator=(v);
66	return *this;
67	}
68
69	/**
70	* Retunrs reference of the first element of Vector3.
71	* @return reference of the first element of Vector3
72	*/
73	inline double& x() { return data_[0];}
74
75	/**
76	* Retunrs the first element of Vector3.
77	* @return the first element of Vector3
78	*/
79	inline double x() const { return data_[0];}
80
81	/**
82	* Retunrs reference of the second element of Vector3.
83	* @return reference of the second element of Vector3
84	*/
85	inline double& y() { return data_[1];}
86
87	/**
88	* Retunrs the second element of Vector3.
89	* @return c the second element of Vector3
90	*/
91	inline double y() const { return data_[1];}
92
93	/**
94	* Retunrs reference of the third element of Vector3.
95	* @return reference of the third element of Vector3
96	*/
97	inline double& z() { return data_[2];}
98
99	/**
100	* Retunrs the third element of Vector3.
101	* @return f the third element of Vector3
102	*/
103	inline double z() const { return data_[2];}
104
105	};
106
107	/**
108	* Returns the cross product of two Vectors
109	* @param v1 first vector
110	* @param v2 second vector
111	* @return the cross product of v1 and v2
112	* @see #vector::dot
113	*/
114	template<typename Real>
115	Vector3<Real> cross( const Vector3<Real>& v1, const Vector3<Real>& v2 ) {
116	Vector3<Real> result;
117
118	result.x() = v1.y() * v2.z() - v1.z() * v2.y();
119	result.y() = v1.z() * v2.x() - v1.x() * v2.z();
120	result.z() = v1.x() * v2.y() - v1.y() * v2.x();
121
122	return result;
123	}
124
125	}
126
127
128	#endif