TAPsDoc/html/_t_a_ps_vector_8cpp_source.html

00001 /******************************************************************************
00002 TAPsVector.cpp
00003 ******************************************************************************/
00007 /******************************************************************************
00008 SUKITTI PUNAK   (09/05/2004)
00009 UPDATE          (08/27/2010)
00010 ******************************************************************************/
00011 #include "TAPsVector.hpp"
00012 // Using Inclusion Model (i.e. definitions are included in declarations)
00013 //                       (this name.cpp is included in name.hpp)
00014 // Each friend is defined directly inside its declaration.
00015
00016 BEGIN_NAMESPACE_TAPs
00017 //=============================================================================
00018 //-----------------------------------------------------------------------------
00019 // Static Data Members for Data Conversions
00020 template <typename T, int N> float          Vector<T,N>::g_f[N];
00021 template <typename T, int N> double         Vector<T,N>::g_d[N];
00022 template <typename T, int N> long double    Vector<T,N>::g_ld[N];
00023 //=============================================================================
00024 // Constructors
00025 //-----------------------------------------------------------------------------
00026 template <typename T, int N>
00027 Vector<T,N>::Vector ()
00028 {
00029     for ( int i = 0; i < N; ++i )
00030         t[i] = Math<T>::ZERO;
00031 }
00032 //-----------------------------------------------------------------------------
00033 template <typename T, int N>
00034 Vector<T,N>::Vector ( T const af[N] )
00035 {
00036     for ( int i = 0; i < N; ++i )
00037         t[i] = af[i];
00038 }
00039 //-----------------------------------------------------------------------------
00040 template <typename T, int N>
00041 Vector<T,N>::Vector ( Vector<T,N> const &v )
00042 {
00043     for ( int i = 0; i < N; ++i )
00044         t[i] = v.t[i];
00045 }
00046 //-----------------------------------------------------------------------------
00047 template <typename T, int N>
00048 Vector<T,N>::~Vector ()
00049 {}
00050 //-----------------------------------------------------------------------------
00051 //=============================================================================
00052 // Member Access
00053 //-----------------------------------------------------------------------------
00054 template <typename T, int N>
00055 T & Vector<T,N>::operator[] ( int i )
00056 {
00057     assert( 0 <= i && i < N );
00058     return t[i];
00059 }
00060 //-----------------------------------------------------------------------------
00061 template <typename T, int N>
00062 T const & Vector<T,N>::operator[] ( int i ) const
00063 {
00064     assert( 0 <= i && i < N );
00065     return t[i];
00066 }
00067 //-----------------------------------------------------------------------------
00068 template <typename T, int N>
00069 int Vector<T,N>::Size () const
00070 {
00071     return N;
00072 }
00073 //-----------------------------------------------------------------------------
00074 //=============================================================================
00075 // Convert to one dimension array
00076 //-----------------------------------------------------------------------------
00077 template <typename T, int N>
00078 Vector<T,N>::operator T * ()
00079 {   return t;   }
00080 //-----------------------------------------------------------------------------
00081 template <typename T, int N>
00082 Vector<T,N>::operator const T * () const
00083 {   return t;   }
00084 //-----------------------------------------------------------------------------
00085 //=============================================================================
00086 // Assignment Operator
00087 //-----------------------------------------------------------------------------
00088 template <typename T, int N>
00089 Vector<T,N> & Vector<T,N>::operator= ( Vector<T,N> const &v )
00090 {
00091     if ( this != &v )
00092     {
00093         for ( int i = 0; i < N; ++i )   t[i] = v.t[i];
00094     }
00095     return *this;
00096 }
00097 //=============================================================================
00098 // Comparison Operators
00099 //-----------------------------------------------------------------------------
00100 template <typename T, int N>
00101 bool Vector<T,N>::operator== ( Vector<T,N> const &v ) const
00102 {
00103     for ( int i = 0; i < N; ++i )
00104         if ( t[i] != v.t[i] ) return false;
00105     return true;
00106 }
00107 //-----------------------------------------------------------------------------
00108 template <typename T, int N>
00109 bool Vector<T,N>::operator!= ( Vector<T,N> const &v ) const
00110 {   return !( *this == v ); }
00111 //-----------------------------------------------------------------------------
00112 template <typename T, int N>
00113 bool Vector<T,N>::operator<= ( Vector<T,N> const &v ) const
00114 {
00115     for ( int i = 0; i < N; ++i )
00116         if ( t[i] > v.t[i] ) return false;
00117     return true;
00118 }
00119 //-----------------------------------------------------------------------------
00120 template <typename T, int N>
00121 bool Vector<T,N>::operator> ( Vector<T,N> const &v ) const
00122 {   return !( *this <= v ); }
00123 //-----------------------------------------------------------------------------
00124 template <typename T, int N>
00125 bool Vector<T,N>::operator>= ( Vector<T,N> const &v ) const
00126 {
00127     for ( int i = 0; i < N; ++i )
00128         if ( t[i] < v.t[i] ) return false;
00129     return true;
00130 }
00131 //-----------------------------------------------------------------------------
00132 template <typename T, int N>
00133 bool Vector<T,N>::operator< ( Vector<T,N> const &v ) const
00134 {   return !( *this >= v ); }
00135 //-----------------------------------------------------------------------------
00136 //=============================================================================
00137 // Arithmetic Operations
00138 //-----------------------------------------------------------------------------
00139 template <typename T, int N>
00140 Vector<T,N> Vector<T,N>::operator- () const
00141 {
00142     Vector<T,N> retVector;
00143     for ( int i = 0; i < N; ++i )   retVector.t[i] = -t[i];
00144     return retVector;
00145 }
00146 //-----------------------------------------------------------------------------
00147 template <typename T, int N>
00148 Vector<T,N> Vector<T,N>::operator+ ( Vector<T,N> const &v ) const
00149 {
00150     Vector<T,N> retVector;
00151     for ( int i = 0; i < N; ++i )   retVector.t[i] = t[i] + v.t[i];
00152     return retVector;
00153 }
00154 //-----------------------------------------------------------------------------
00155 template <typename T, int N>
00156 Vector<T,N> Vector<T,N>::operator- ( Vector<T,N> const &v ) const
00157 {
00158     Vector<T,N> retVector;
00159     for ( int i = 0; i < N; ++i )   retVector.t[i] = t[i] - v.t[i];
00160     return retVector;
00161 }
00162 //-----------------------------------------------------------------------------
00163 template <typename T, int N>
00164 Vector<T,N> Vector<T,N>::operator* ( T s ) const
00165 {
00166     Vector<T,N> retVector;
00167     for ( int i = 0; i < N; ++i )   retVector.t[i] = t[i] * s;
00168     return retVector;
00169 }
00170 //-----------------------------------------------------------------------------
00171 template <typename T, int N>
00172 Vector<T,N> Vector<T,N>::operator/ ( T s ) const
00173 {
00174     Vector<T,N> retVector;
00175     if ( s != Math<T>::ZERO )
00176         for ( int i = 0; i < N; ++i )   retVector.t[i] = t[i] / s;
00177     else
00178         for ( int i = 0; i < N; ++i )   retVector.t[i] = Math<T>::INFINITY;
00179     return retVector;
00180 }
00181 //-----------------------------------------------------------------------------
00182 //=============================================================================
00183 // Arithmetic Update Operators
00184 //-----------------------------------------------------------------------------
00185 template <typename T, int N>
00186 Vector<T,N> & Vector<T,N>::operator+= ( Vector<T,N> const &v )
00187 {
00188     for ( int i = 0; i < N; ++ i )  t[i] += v.t[i];
00189     return *this;
00190 }
00191 //-----------------------------------------------------------------------------
00192 template <typename T, int N>
00193 Vector<T,N> & Vector<T,N>::operator-= ( Vector<T,N> const &v )
00194 {
00195     for ( int i = 0; i < N; ++ i )  t[i] -= v.t[i];
00196     return *this;
00197 }
00198 //-----------------------------------------------------------------------------
00199 template <typename T, int N>
00200 Vector<T,N> & Vector<T,N>::operator*= ( T s )
00201 {
00202     for ( int i = 0; i < N; ++ i )  t[i] *= s;
00203     return *this;
00204 }
00205 //-----------------------------------------------------------------------------
00206 template <typename T, int N>
00207 Vector<T,N> & Vector<T,N>::operator/= ( T s )
00208 {
00209     if ( s != Math<T>::ZERO )
00210         for ( int i = 0; i < N; ++ i )  t[i] /= s;
00211     else
00212         for ( int i = 0; i < N; ++ i )  t[i] = Math<T>::INFINITY;
00213     return *this;
00214 }
00215 //-----------------------------------------------------------------------------
00216 //=============================================================================
00217 // Vector Operations
00218 //-----------------------------------------------------------------------------
00219 template <typename T, int N>
00220 T Vector<T,N>::Length () const
00221 {
00222     T f = Math<T>::ZERO;
00223     for ( int i = 0; i < N; ++i )   f += t[i]*t[i];
00224     return Math<T>::Sqrt( f );
00225 }
00226 //-----------------------------------------------------------------------------
00227 template <typename T, int N>
00228 T Vector<T,N>::Magnitude () const
00229 {
00230     return Length();
00231 }
00232 //-----------------------------------------------------------------------------
00233 template <typename T, int N>
00234 T Vector<T,N>::SquaredLength () const
00235 {
00236     T f = Math<T>::ZERO;
00237     for ( int i = 0; i < N; ++i )   f += t[i]*t[i];
00238     return f;
00239 }
00240 //-----------------------------------------------------------------------------
00241 template <typename T, int N>
00242 Vector<T,N> Vector<T,N>::GetUnit ( T tolerance ) const
00243 {
00244     T fLength = Vector<T,N>::Length();
00245     Vector<T,N> retVector;
00246     if ( fLength > tolerance )
00247         for ( int i = 0; i < N; ++i )   retVector.t[i] = t[i] / fLength;
00248     else
00249         for ( int i = 0; i < N; ++i )   retVector.t[i] = Math<T>::ZERO;
00250     return retVector;
00251 }
00252 //-----------------------------------------------------------------------------
00253 template <typename T, int N>
00254 Vector<T,N> & Vector<T,N>::Normalized ( T tolerance )
00255 {
00256     T fLength = Vector<T,N>::Length();
00257     if ( fLength > tolerance )
00258         for ( int i = 0; i < N; ++i )   t[i] /= fLength;
00259     else
00260         for ( int i = 0; i < N; ++i )   t[i] = Math<T>::ZERO;
00261     return *this;
00262 }
00263 //-----------------------------------------------------------------------------
00264 template <typename T, int N>
00265 T Vector<T,N>::Dot ( Vector<T,N> const &v ) const
00266 {
00267     T f = Math<T>::ZERO;
00268     for ( int i = 0; i < N; ++i )   f += t[i]*v.t[i];
00269     return f;
00270 }
00271 //-----------------------------------------------------------------------------
00272 template <typename T, int N>
00273 T Vector<T,N>::operator* ( Vector<T,N> const &v ) const
00274 {   return this->Dot(v);    }
00275 //-----------------------------------------------------------------------------
00276 template <typename T, int N>
00277 Vector<T,N> Vector<T,N>::ComponentWiseMult ( Vector<T,N> const &v ) const
00278 {
00279     Vector<T,N> R;
00280     for ( int i = 0; i < N; ++i ) {
00281         R.t[i] = t[i] * v.t[i];
00282     }
00283     return R;
00284 }
00285 //-----------------------------------------------------------------------------
00286 template <typename T, int N>
00287 Vector<T,N> Vector<T,N>::ComponentWiseDivs ( Vector<T,N> const &v ) const
00288 {
00289     Vector<T,N> R;
00290     for ( int i = 0; i < N; ++i ) {
00291         R.t[i] = t[i] / v.t[i];
00292     }
00293     return R;
00294 }
00295 //-----------------------------------------------------------------------------
00296 template <typename T, int N>
00297 void Vector<T,N>::UpdateByComponentWiseMult ( Vector<T,N> const &v )
00298 {
00299     for ( int i = 0; i < N; ++i ) {
00300         t[i] *= v.t[i];
00301     }
00302 }
00303 //-----------------------------------------------------------------------------
00304 template <typename T, int N>
00305 void Vector<T,N>::UpdateByComponentWiseDivs ( Vector<T,N> const &v )
00306 {
00307     for ( int i = 0; i < N; ++i ) {
00308         t[i] /= v.t[i];
00309     }
00310 }
00311 //-----------------------------------------------------------------------------
00312
00313 //=============================================================================
00314 // Static Member Functions for Data Conversions
00315 //-----------------------------------------------------------------------------
00316 template <typename T, int N>
00317 const float * Vector<T,N>::GetDataFloat () const
00318 {
00319     for ( int i = 0; i < N; ++i ) {
00320         g_f[i] = static_cast<float>( t[i] );
00321     }
00322     return g_f;
00323 }
00324 //-----------------------------------------------------------------------------
00325 template <typename T, int N>
00326 const double * Vector<T,N>::GetDataDouble () const
00327 {
00328     for ( int i = 0; i < N; ++i ) {
00329         g_d[i] = static_cast<double>( t[i] );
00330     }
00331     return g_d;
00332 }
00333 //-----------------------------------------------------------------------------
00334 template <typename T, int N>
00335 const long double * Vector<T,N>::GetDataLongDouble () const
00336 {
00337     for ( int i = 0; i < N; ++i ) {
00338         g_ld[i] = static_cast<long double>( t[i] );
00339     }
00340     return g_ld;
00341 }
00342 //-----------------------------------------------------------------------------
00343 template <typename T, int N>
00344 float * Vector<T,N>::GetDataFloat ()
00345 {
00346     for ( int i = 0; i < N; ++i ) {
00347         g_f[i] = static_cast<float>( t[i] );
00348     }
00349     return g_f;
00350 }
00351 //-----------------------------------------------------------------------------
00352 template <typename T, int N>
00353 double * Vector<T,N>::GetDataDouble ()
00354 {
00355     for ( int i = 0; i < N; ++i ) {
00356         g_d[i] = static_cast<double>( t[i] );
00357     }
00358     return g_d;
00359 }
00360 //-----------------------------------------------------------------------------
00361 template <typename T, int N>
00362 long double * Vector<T,N>::GetDataLongDouble ()
00363 {
00364     for ( int i = 0; i < N; ++i ) {
00365         g_ld[i] = static_cast<long double>( t[i] );
00366     }
00367     return g_ld;
00368 }
00369 //-----------------------------------------------------------------------------
00370
00371 /*
00372 //=============================================================================
00373 // Global Functions
00374 //-----------------------------------------------------------------------------
00375 // Std Output Via << Operator
00376 template <typename T, int N>
00377 std::ostream & operator<< ( std::ostream &output, Vector<T,N> const &v )
00378 {
00379     output << typeid(v).name() << "( ";
00380     //output << "Vector<" << typeid(T).name() << "," << N << ">( ";
00381     for ( int i = 0; i < N-1; ++i )
00382     {
00383         output << v[i] << ", ";
00384     }
00385     output << v[i] << " )'"; //<< std::endl;
00386     return output;
00387 }
00388 //-----------------------------------------------------------------------------
00389 */
00390
00391 //=============================================================================
00392 END_NAMESPACE_TAPs
00393 //345678901234567890123456789012345678901234567890123456789012345678901234567890
00394 //--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8