#ifndef ROOT_Math_GenVector_DisplacementVector2D
#define ROOT_Math_GenVector_DisplacementVector2D 1
#ifndef ROOT_Math_GenVector_Cartesian2D
#include "Math/GenVector/Cartesian2D.h"
#endif
#ifndef ROOT_Math_GenVector_PositionVector2Dfwd
#include "Math/GenVector/PositionVector2Dfwd.h"
#endif
#ifndef ROOT_Math_GenVector_GenVectorIO
#include "Math/GenVector/GenVectorIO.h"
#endif
#ifndef ROOT_Math_GenVector_BitReproducible
#include "Math/GenVector/BitReproducible.h"
#endif
#ifndef ROOT_Math_GenVector_CoordinateSystemTags
#include "Math/GenVector/CoordinateSystemTags.h"
#endif
#include <cassert>
namespace ROOT {
namespace Math {
template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
class DisplacementVector2D {
public:
typedef typename CoordSystem::Scalar Scalar;
typedef CoordSystem CoordinateType;
typedef Tag CoordinateSystemTag;
DisplacementVector2D ( ) : fCoordinates() { }
DisplacementVector2D(Scalar a, Scalar b) :
fCoordinates ( a , b ) { }
template <class OtherCoords>
explicit DisplacementVector2D( const DisplacementVector2D<OtherCoords, Tag> & v) :
fCoordinates ( v.Coordinates() ) { }
template <class OtherCoords>
explicit DisplacementVector2D( const PositionVector2D<OtherCoords,Tag> & p) :
fCoordinates ( p.Coordinates() ) { }
template <class ForeignVector>
explicit DisplacementVector2D( const ForeignVector & v) :
fCoordinates ( Cartesian2D<Scalar>( v.x(), v.y() ) ) { }
template <class OtherCoords>
DisplacementVector2D & operator=
( const DisplacementVector2D<OtherCoords, Tag> & v) {
fCoordinates = v.Coordinates();
return *this;
}
template <class OtherCoords>
DisplacementVector2D & operator=
( const PositionVector2D<OtherCoords,Tag> & rhs) {
SetXY(rhs.x(), rhs.y() );
return *this;
}
template <class ForeignVector>
DisplacementVector2D & operator= ( const ForeignVector & v) {
SetXY( v.x(), v.y() );
return *this;
}
CoordSystem Coordinates() const {
return fCoordinates;
}
void SetCoordinates( Scalar a, Scalar b)
{ fCoordinates.SetCoordinates(a, b); }
void GetCoordinates( Scalar& a, Scalar& b) const
{ fCoordinates.GetCoordinates(a, b); }
void SetXY (Scalar x, Scalar y) {
fCoordinates.SetXY(x,y);
}
bool operator==(const DisplacementVector2D & rhs) const {
return fCoordinates==rhs.fCoordinates;
}
bool operator!= (const DisplacementVector2D & rhs) const {
return !(operator==(rhs));
}
Scalar X() const { return fCoordinates.X(); }
Scalar Y() const { return fCoordinates.Y(); }
Scalar R() const { return fCoordinates.R(); }
Scalar Phi() const { return fCoordinates.Phi(); }
Scalar Mag2() const { return fCoordinates.Mag2();}
DisplacementVector2D Unit() const {
Scalar tot = R();
return tot == 0 ? *this : DisplacementVector2D(*this) / tot;
}
void SetX (Scalar x) { fCoordinates.SetX(x); }
void SetY (Scalar y) { fCoordinates.SetY(y); }
void SetR (Scalar r) { fCoordinates.SetR(r); }
void SetPhi (Scalar phi) { fCoordinates.SetPhi(phi); }
template< class OtherCoords >
Scalar Dot( const DisplacementVector2D<OtherCoords,Tag> & v) const {
return X()*v.X() + Y()*v.Y();
}
template< class OtherVector >
Scalar Dot( const OtherVector & v) const {
return X()*v.x() + Y()*v.y();
}
template <class OtherCoords>
DisplacementVector2D & operator+=
(const DisplacementVector2D<OtherCoords,Tag> & v) {
SetXY( X() + v.X(), Y() + v.Y() );
return *this;
}
template <class OtherCoords>
DisplacementVector2D & operator-=
(const DisplacementVector2D<OtherCoords,Tag> & v) {
SetXY( x() - v.x(), y() - v.y() );
return *this;
}
DisplacementVector2D & operator*= (Scalar a) {
fCoordinates.Scale(a);
return *this;
}
DisplacementVector2D & operator/= (Scalar a) {
fCoordinates.Scale(1/a);
return *this;
}
DisplacementVector2D operator * ( Scalar a ) const {
DisplacementVector2D tmp(*this);
tmp *= a;
return tmp;
}
DisplacementVector2D operator - ( ) const {
return operator*( Scalar(-1) );
}
DisplacementVector2D operator + ( ) const {return *this;}
DisplacementVector2D operator/ (Scalar a) const {
DisplacementVector2D tmp(*this);
tmp /= a;
return tmp;
}
void Rotate( Scalar angle) {
return fCoordinates.Rotate(angle);
}
Scalar x() const { return fCoordinates.X(); }
Scalar y() const { return fCoordinates.Y(); }
Scalar r() const { return fCoordinates.R(); }
Scalar phi() const { return fCoordinates.Phi(); }
Scalar mag2() const { return fCoordinates.Mag2(); }
DisplacementVector2D unit() const {return Unit();}
private:
CoordSystem fCoordinates;
template <class OtherCoords, class OtherTag>
explicit DisplacementVector2D( const DisplacementVector2D<OtherCoords, OtherTag> & ) {}
template <class OtherCoords, class OtherTag>
explicit DisplacementVector2D( const PositionVector2D<OtherCoords, OtherTag> & ) {}
template <class OtherCoords, class OtherTag>
DisplacementVector2D & operator=( const DisplacementVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
DisplacementVector2D & operator=( const PositionVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
DisplacementVector2D & operator+=(const DisplacementVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
DisplacementVector2D & operator-=(const DisplacementVector2D<OtherCoords, OtherTag> & );
template<class OtherCoords, class OtherTag >
Scalar Dot( const DisplacementVector2D<OtherCoords, OtherTag> & ) const;
template<class OtherCoords, class OtherTag >
DisplacementVector2D Cross( const DisplacementVector2D<OtherCoords, OtherTag> & ) const;
};
template <class CoordSystem1, class CoordSystem2, class U>
inline
DisplacementVector2D<CoordSystem1,U>
operator+( DisplacementVector2D<CoordSystem1,U> v1,
const DisplacementVector2D<CoordSystem2,U> & v2) {
return v1 += v2;
}
template <class CoordSystem1, class CoordSystem2, class U>
inline
DisplacementVector2D<CoordSystem1,U>
operator-( DisplacementVector2D<CoordSystem1,U> v1,
DisplacementVector2D<CoordSystem2,U> const & v2) {
return v1 -= v2;
}
template <class CoordSystem, class U>
inline
DisplacementVector2D<CoordSystem,U>
operator * ( typename DisplacementVector2D<CoordSystem,U>::Scalar a,
DisplacementVector2D<CoordSystem,U> v) {
return v *= a;
}
template< class char_t, class traits_t, class T, class U >
inline
std::basic_ostream<char_t,traits_t> &
operator << ( std::basic_ostream<char_t,traits_t> & os
, DisplacementVector2D<T,U> const & v
)
{
if( !os ) return os;
typename T::Scalar a, b;
v.GetCoordinates(a, b);
if( detail::get_manip( os, detail::bitforbit ) ) {
detail::set_manip( os, detail::bitforbit, '\00' );
typedef GenVector_detail::BitReproducible BR;
BR::Output(os, a);
BR::Output(os, b);
}
else {
os << detail::get_manip( os, detail::open ) << a
<< detail::get_manip( os, detail::sep ) << b
<< detail::get_manip( os, detail::close );
}
return os;
}
template< class char_t, class traits_t, class T, class U >
inline
std::basic_istream<char_t,traits_t> &
operator >> ( std::basic_istream<char_t,traits_t> & is
, DisplacementVector2D<T,U> & v
)
{
if( !is ) return is;
typename T::Scalar a, b;
if( detail::get_manip( is, detail::bitforbit ) ) {
detail::set_manip( is, detail::bitforbit, '\00' );
typedef GenVector_detail::BitReproducible BR;
BR::Input(is, a);
BR::Input(is, b);
}
else {
detail::require_delim( is, detail::open ); is >> a;
detail::require_delim( is, detail::sep ); is >> b;
detail::require_delim( is, detail::close );
}
if( is )
v.SetCoordinates(a, b);
return is;
}
}
}
#endif /* ROOT_Math_GenVector_DisplacementVector2D */
Last update: Thu Jan 17 08:41:24 2008
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.