1 /* Boost libs/numeric/odeint/examples/point_type.hpp 2 3 Copyright 2010-2012 Karsten Ahnert 4 Copyright 2011 Mario Mulansky 5 6 solar system example for Hamiltonian stepper 7 8 Distributed under the Boost Software License, Version 1.0. 9 (See accompanying file LICENSE_1_0.txt or 10 copy at http://www.boost.org/LICENSE_1_0.txt) 11 */ 12 13 #ifndef POINT_TYPE_HPP_INCLUDED 14 #define POINT_TYPE_HPP_INCLUDED 15 16 17 #include <boost/operators.hpp> 18 #include <ostream> 19 20 21 //[ point_type 22 /*the point type */ 23 template< class T , size_t Dim > 24 class point : 25 boost::additive1< point< T , Dim > , 26 boost::additive2< point< T , Dim > , T , 27 boost::multiplicative2< point< T , Dim > , T 28 > > > 29 { 30 public: 31 32 const static size_t dim = Dim; 33 typedef T value_type; 34 typedef point< value_type , dim > point_type; 35 36 // ... 37 // constructors 38 //<- point(void)39 point( void ) 40 { 41 for( size_t i=0 ; i<dim ; ++i ) m_val[i] = 0.0; 42 } 43 point(value_type val)44 point( value_type val ) 45 { 46 for( size_t i=0 ; i<dim ; ++i ) m_val[i] = val; 47 } 48 point(value_type x,value_type y,value_type z=0.0)49 point( value_type x , value_type y , value_type z = 0.0 ) 50 { 51 if( dim > 0 ) m_val[0] = x; 52 if( dim > 1 ) m_val[1] = y; 53 if( dim > 2 ) m_val[2] = z; 54 } 55 //-> 56 57 // ... 58 // operators 59 //<- operator [](size_t i) const60 T operator[]( size_t i ) const { return m_val[i]; } operator [](size_t i)61 T& operator[]( size_t i ) { return m_val[i]; } 62 operator +=(const point_type & p)63 point_type& operator+=( const point_type& p ) 64 { 65 for( size_t i=0 ; i<dim ; ++i ) 66 m_val[i] += p[i]; 67 return *this; 68 } 69 operator -=(const point_type & p)70 point_type& operator-=( const point_type& p ) 71 { 72 for( size_t i=0 ; i<dim ; ++i ) 73 m_val[i] -= p[i]; 74 return *this; 75 } 76 operator +=(const value_type & val)77 point_type& operator+=( const value_type& val ) 78 { 79 for( size_t i=0 ; i<dim ; ++i ) 80 m_val[i] += val; 81 return *this; 82 } 83 operator -=(const value_type & val)84 point_type& operator-=( const value_type& val ) 85 { 86 for( size_t i=0 ; i<dim ; ++i ) 87 m_val[i] -= val; 88 return *this; 89 } 90 operator *=(const value_type & val)91 point_type& operator*=( const value_type &val ) 92 { 93 for( size_t i=0 ; i<dim ; ++i ) 94 m_val[i] *= val; 95 return *this; 96 } 97 operator /=(const value_type & val)98 point_type& operator/=( const value_type &val ) 99 { 100 for( size_t i=0 ; i<dim ; ++i ) 101 m_val[i] /= val; 102 return *this; 103 } 104 105 //-> 106 107 private: 108 109 T m_val[dim]; 110 }; 111 112 //... 113 // more operators 114 //] 115 116 // 117 // the - operator 118 // 119 template< class T , size_t Dim > operator -(const point<T,Dim> & p)120 point< T , Dim > operator-( const point< T , Dim > &p ) 121 { 122 point< T , Dim > tmp; 123 for( size_t i=0 ; i<Dim ; ++i ) tmp[i] = -p[i]; 124 return tmp; 125 } 126 127 // 128 // scalar product 129 // 130 template< class T , size_t Dim > scalar_prod(const point<T,Dim> & p1,const point<T,Dim> & p2)131 T scalar_prod( const point< T , Dim > &p1 , const point< T , Dim > &p2 ) 132 { 133 T tmp = 0.0; 134 for( size_t i=0 ; i<Dim ; ++i ) tmp += p1[i] * p2[i]; 135 return tmp; 136 } 137 138 139 140 // 141 // norm 142 // 143 template< class T , size_t Dim > norm(const point<T,Dim> & p1)144 T norm( const point< T , Dim > &p1 ) 145 { 146 return scalar_prod( p1 , p1 ); 147 } 148 149 150 151 152 // 153 // absolute value 154 // 155 template< class T , size_t Dim > abs(const point<T,Dim> & p1)156 T abs( const point< T , Dim > &p1 ) 157 { 158 return sqrt( norm( p1 ) ); 159 } 160 161 162 163 164 // 165 // output operator 166 // 167 template< class T , size_t Dim > operator <<(std::ostream & out,const point<T,Dim> & p)168 std::ostream& operator<<( std::ostream &out , const point< T , Dim > &p ) 169 { 170 if( Dim > 0 ) out << p[0]; 171 for( size_t i=1 ; i<Dim ; ++i ) out << " " << p[i]; 172 return out; 173 } 174 175 176 177 #endif //POINT_TYPE_HPP_INCLUDED 178