#ifndef ROOT_Math_GenVector_PositionVector2D
#define ROOT_Math_GenVector_PositionVector2D 1
#ifndef ROOT_Math_GenVector_DisplacementVector2Dfwd
#include "Math/GenVector/DisplacementVector2D.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 PositionVector2D {
public:
typedef typename CoordSystem::Scalar Scalar;
typedef CoordSystem CoordinateType;
typedef Tag CoordinateSystemTag;
PositionVector2D() : fCoordinates() { }
PositionVector2D(const Scalar & a, const Scalar & b) :
fCoordinates ( a , b) { }
template <class T>
explicit PositionVector2D( const PositionVector2D<T,Tag> & v) :
fCoordinates ( v.Coordinates() ) { }
template <class T>
explicit PositionVector2D( const DisplacementVector2D<T,Tag> & p) :
fCoordinates ( p.Coordinates() ) { }
template <class ForeignVector>
explicit PositionVector2D( const ForeignVector & v) :
fCoordinates ( Cartesian2D<Scalar>( v.x(), v.y() ) ) { }
template <class OtherCoords>
PositionVector2D & operator=
( const PositionVector2D<OtherCoords,Tag> & v) {
fCoordinates = v.Coordinates();
return *this;
}
template <class OtherCoords>
PositionVector2D & operator=
( const DisplacementVector2D<OtherCoords,Tag> & v) {
fCoordinates = v.Coordinates();
return *this;
}
template <class ForeignVector>
PositionVector2D & operator= ( const ForeignVector & v) {
SetXY( v.x(), v.y() );
return *this;
}
const 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 PositionVector2D & rhs) const {
return fCoordinates==rhs.fCoordinates;
}
bool operator!= (const PositionVector2D & 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();}
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 OtherCoords>
PositionVector2D & operator+= (const DisplacementVector2D<OtherCoords,Tag> & v)
{
SetXY( X() + v.X(), Y() + v.Y() );
return *this;
}
template <class OtherCoords>
PositionVector2D & operator-= (const DisplacementVector2D<OtherCoords,Tag> & v)
{
SetXY( X() - v.X(), Y() - v.Y() );
return *this;
}
PositionVector2D & operator *= (Scalar a) {
fCoordinates.Scale(a);
return *this;
}
PositionVector2D & operator /= (Scalar a) {
fCoordinates.Scale(1/a);
return *this;
}
PositionVector2D operator * ( Scalar a ) const {
PositionVector2D tmp(*this);
tmp *= a;
return tmp;
}
PositionVector2D operator / (Scalar a) const {
PositionVector2D 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(); }
private:
CoordSystem fCoordinates;
template <class OtherCoords, class OtherTag>
explicit PositionVector2D( const PositionVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
explicit PositionVector2D( const DisplacementVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
PositionVector2D & operator=( const PositionVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
PositionVector2D & operator=( const DisplacementVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
PositionVector2D & operator+=(const DisplacementVector2D<OtherCoords, OtherTag> & );
template <class OtherCoords, class OtherTag>
PositionVector2D & operator-=(const DisplacementVector2D<OtherCoords, OtherTag> & );
};
template <class CoordSystem, class U>
inline
PositionVector2D<CoordSystem>
operator * ( typename PositionVector2D<CoordSystem,U>::Scalar a,
PositionVector2D<CoordSystem,U> v) {
return v *= a;
}
template <class CoordSystem1, class CoordSystem2, class U>
inline
DisplacementVector2D<CoordSystem1,U>
operator-( const PositionVector2D<CoordSystem1,U> & v1,
const PositionVector2D<CoordSystem2,U> & v2) {
return DisplacementVector2D<CoordSystem1,U>( Cartesian2D<typename CoordSystem1::Scalar>(
v1.X()-v2.X(), v1.Y()-v2.Y() )
);
}
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector2D<CoordSystem2,U>
operator+( PositionVector2D<CoordSystem2,U> p1,
const DisplacementVector2D<CoordSystem1,U> & v2) {
return p1 += v2;
}
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector2D<CoordSystem2,U>
operator+( DisplacementVector2D<CoordSystem1,U> const & v1,
PositionVector2D<CoordSystem2,U> p2) {
return p2 += v1;
}
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector2D<CoordSystem2,U>
operator-( PositionVector2D<CoordSystem2,U> p1,
DisplacementVector2D<CoordSystem1,U> const & v2) {
return p1 -= v2;
}
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
, PositionVector2D<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
, PositionVector2D<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_PositionVector2D */
Last update: Thu Jan 17 08:41:58 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.