```// @(#)root/mathcore:\$Id: PositionVector2D.h 38652 2011-03-29 14:24:43Z moneta \$
// Authors: W. Brown, M. Fischler, L. Moneta    2005

/**********************************************************************
*                                                                    *
* Copyright (c) 2005 , LCG ROOT MathLib Team                         *
*                                                                    *
*                                                                    *
**********************************************************************/

// Header file for class PositionVector2D
//
// Created by: Lorenzo Moneta  at Mon Apr 16 2007
//
//
#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

namespace ROOT {

namespace Math {

//__________________________________________________________________________________________
/**
Class describing a generic position vector (point) in 2 dimensions.
This class is templated on the type of Coordinate system.
One example is the XYPoint which is a vector based on
double precision x,y data members by using the
ROOT::Math::Cartesian2D<double> Coordinate system.
The class is having also an extra template parameter, the coordinate system tag,
to be able to identify (tag) vector described in different reference coordinate system,
like global or local coordinate systems.

@ingroup GenVector
*/

template <class CoordSystem, class Tag = DefaultCoordinateSystemTag >
class PositionVector2D {

public:

typedef typename CoordSystem::Scalar Scalar;
typedef CoordSystem CoordinateType;
typedef Tag  CoordinateSystemTag;

// ------ ctors ------

/**
Default constructor. Construct an empty object with zero values
*/

PositionVector2D() : fCoordinates() { }

/**
Construct from three values of type <em>Scalar</em>.
In the case of a XYPoint the values are x,y
In the case of  a polar vector they are r,phi
*/
PositionVector2D(const Scalar & a, const Scalar & b) :
fCoordinates ( a , b)  { }

/**
Construct from a position vector expressed in different
coordinates, or using a different Scalar type
*/
template <class T>
explicit PositionVector2D( const PositionVector2D<T,Tag> & v) :
fCoordinates ( v.Coordinates() ) { }

/**
Construct from an arbitrary displacement vector
*/
template <class T>
explicit PositionVector2D( const DisplacementVector2D<T,Tag> & p) :
fCoordinates ( p.Coordinates() ) { }

/**
Construct from a foreign 2D vector type, for example, Hep2Vector
Precondition: v must implement methods x() and  y()
*/
template <class ForeignVector>
explicit PositionVector2D( const ForeignVector & v) :
fCoordinates ( Cartesian2D<Scalar>( v.x(), v.y() ) ) { }

// compiler-generated copy ctor and dtor are fine.

// ------ assignment ------

/**
Assignment operator from a position vector of arbitrary type
*/
template <class OtherCoords>
PositionVector2D & operator=
( const PositionVector2D<OtherCoords,Tag> & v) {
fCoordinates = v.Coordinates();
return *this;
}

/**
Assignment operator from a displacement vector of arbitrary type
*/
template <class OtherCoords>
PositionVector2D & operator=
( const DisplacementVector2D<OtherCoords,Tag> & v) {
fCoordinates = v.Coordinates();
return *this;
}

/**
Assignment from a foreign 2D vector type, for example, Hep2Vector
Precondition: v must implement methods x() and y()
*/
template <class ForeignVector>
PositionVector2D & operator= ( const ForeignVector & v) {
SetXY( v.x(),  v.y() );
return *this;
}

/**
Retrieve a copy of the coordinates object
*/
const CoordSystem & Coordinates() const {
return fCoordinates;
}

/**
Set internal data based on 2 Scalar numbers.
These are for example (x,y) for a cartesian vector or (r,phi) for a polar vector
*/
PositionVector2D<CoordSystem, Tag>& SetCoordinates( Scalar a, Scalar b) {
fCoordinates.SetCoordinates(a, b);
return *this;
}

/**
get internal data into 2 Scalar numbers.
These are for example (x,y) for a cartesian vector or (r,phi) for a polar vector
*/
void GetCoordinates( Scalar& a, Scalar& b) const
{ fCoordinates.GetCoordinates(a, b);  }

/**
set the values of the vector from the cartesian components (x,y)
(if the vector is held in polar coordinates,
then (x, y) are converted to that form)
*/
PositionVector2D<CoordSystem, Tag>& SetXY (Scalar a, Scalar b) {
fCoordinates.SetXY (a,b);
return *this;
}

// ------------------- Equality -----------------

/**
Exact equality
*/
bool operator==(const PositionVector2D & rhs) const {
return fCoordinates==rhs.fCoordinates;
}
bool operator!= (const PositionVector2D & rhs) const {
return !(operator==(rhs));
}

// ------ Individual element access, in various coordinate systems ------

/**
Cartesian X, converting if necessary from internal coordinate system.
*/
Scalar X() const { return fCoordinates.X(); }

/**
Cartesian Y, converting if necessary from internal coordinate system.
*/
Scalar Y() const { return fCoordinates.Y(); }

/**
Polar R, converting if necessary from internal coordinate system.
*/
Scalar R() const { return fCoordinates.R(); }

/**
Polar phi, converting if necessary from internal coordinate system.
*/
Scalar Phi() const { return fCoordinates.Phi(); }

/**
Magnitute squared ( r^2 in spherical coordinate)
*/
Scalar Mag2() const { return fCoordinates.Mag2();}

// It is physically meaningless to speak of the unit vector corresponding
// to a point.

// ------ Setting individual elements present in coordinate system ------

/**
Change X - Cartesian2D coordinates only
*/
PositionVector2D<CoordSystem, Tag>& SetX (Scalar a) {
fCoordinates.SetX(a);
return *this;
}

/**
Change Y - Cartesian2D coordinates only
*/
PositionVector2D<CoordSystem, Tag>& SetY (Scalar a) {
fCoordinates.SetY(a);
return *this;
}

/**
Change R - Polar2D coordinates only
*/
PositionVector2D<CoordSystem, Tag>& SetR (Scalar a) {
fCoordinates.SetR(a);
return *this;
}

/**
Change Phi - Polar2D coordinates
*/
PositionVector2D<CoordSystem, Tag>& SetPhi (Scalar ang) {
fCoordinates.SetPhi(ang);
return *this;
}

// ------ Operations combining two vectors ------
// need to specialize to exclude those with a different tags

/**
Return the scalar (Dot) product of this with a displacement vector in
any coordinate system, but with the same tag
*/
template< class OtherCoords >
Scalar Dot( const  DisplacementVector2D<OtherCoords,Tag> & v) const {
return X()*v.x() + Y()*v.y();
}

// The Dot product of a pair of point vectors are physically
// meaningless concepts and thus are defined as private methods

/**
Self Addition with a displacement vector.
*/
template <class OtherCoords>
PositionVector2D & operator+= (const  DisplacementVector2D<OtherCoords,Tag> & v)
{
SetXY( X() + v.X(), Y() + v.Y() );
return *this;
}

/**
Self Difference with a displacement vector.
*/
template <class OtherCoords>
PositionVector2D & operator-= (const  DisplacementVector2D<OtherCoords,Tag> & v)
{
SetXY(  X() - v.X(), Y() - v.Y() );
return *this;
}

/**
multiply this vector by a scalar quantity
*/
PositionVector2D & operator *= (Scalar a) {
fCoordinates.Scale(a);
return *this;
}

/**
divide this vector by a scalar quantity
*/
PositionVector2D & operator /= (Scalar a) {
fCoordinates.Scale(1/a);
return *this;
}

// The following methods (v*a and v/a) could instead be free functions.
// They were moved into the class to solve a problem on AIX.
/**
Multiply a vector by a real number
*/
PositionVector2D operator * ( Scalar a ) const {
PositionVector2D tmp(*this);
tmp *= a;
return tmp;
}

/**
Division of a vector with a real number
*/
PositionVector2D operator / (Scalar a) const {
PositionVector2D tmp(*this);
tmp /= a;
return tmp;
}

/**
Rotate by an angle
*/
void Rotate( Scalar angle) {
return fCoordinates.Rotate(angle);
}

// Limited backward name compatibility with CLHEP

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;

// Prohibited methods

// this should not compile (if from a vector or points with different tag

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> & );

//       /**
//          Dot product of two position vectors is inappropriate
//       */
//       template <class T2, class U>
//       PositionVector2D Dot( const PositionVector2D<T2,U> & v) const;

};

// ---------- PositionVector2D class template ends here ----------------
// ---------------------------------------------------------------------

/**
Multiplication of a position vector by real number  a*v
*/
template <class CoordSystem, class U>
inline
PositionVector2D<CoordSystem>
operator * ( typename PositionVector2D<CoordSystem,U>::Scalar a,
PositionVector2D<CoordSystem,U> v) {
return v *= a;
// Note - passing v by value and using operator *= may save one
// copy relative to passing v by const ref and creating a temporary.
}

/**
Difference between two PositionVector2D vectors.
The result is a DisplacementVector2D.
The (coordinate system) type of the returned vector is defined to
be identical to that of the first position vector.
*/

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

/**
Addition of a PositionVector2D and a DisplacementVector2D.
The return type is a PositionVector2D,
of the same (coordinate system) type as the input PositionVector2D.
*/
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector2D<CoordSystem2,U>
operator+( PositionVector2D<CoordSystem2,U> p1,
const DisplacementVector2D<CoordSystem1,U>  & v2)        {
return p1 += v2;
}

/**
Addition of a DisplacementVector2D and a PositionVector2D.
The return type is a PositionVector2D,
of the same (coordinate system) type as the input PositionVector2D.
*/
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector2D<CoordSystem2,U>
operator+( DisplacementVector2D<CoordSystem1,U> const & v1,
PositionVector2D<CoordSystem2,U> p2)        {
return p2 += v1;
}

/**
Subtraction of a DisplacementVector2D from a PositionVector2D.
The return type is a PositionVector2D,
of the same (coordinate system) type as the input PositionVector2D.
*/
template <class CoordSystem1, class CoordSystem2, class U>
inline
PositionVector2D<CoordSystem2,U>
operator-( PositionVector2D<CoordSystem2,U> p1,
DisplacementVector2D<CoordSystem1,U> const & v2)        {
return p1 -= v2;
}

// Scaling of a position vector with a real number is not physically meaningful

// ------------- I/O to/from streams -------------

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;

}  // op<< <>()

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;

}  // op>> <>()

} // namespace Math

} // namespace ROOT

#endif /* ROOT_Math_GenVector_PositionVector2D  */
```
PositionVector2D.h:1
PositionVector2D.h:2
PositionVector2D.h:3
PositionVector2D.h:4
PositionVector2D.h:5
PositionVector2D.h:6
PositionVector2D.h:7
PositionVector2D.h:8
PositionVector2D.h:9
PositionVector2D.h:10
PositionVector2D.h:11
PositionVector2D.h:12
PositionVector2D.h:13
PositionVector2D.h:14
PositionVector2D.h:15
PositionVector2D.h:16
PositionVector2D.h:17
PositionVector2D.h:18
PositionVector2D.h:19
PositionVector2D.h:20
PositionVector2D.h:21
PositionVector2D.h:22
PositionVector2D.h:23
PositionVector2D.h:24
PositionVector2D.h:25
PositionVector2D.h:26
PositionVector2D.h:27
PositionVector2D.h:28
PositionVector2D.h:29
PositionVector2D.h:30
PositionVector2D.h:31
PositionVector2D.h:32
PositionVector2D.h:33
PositionVector2D.h:34
PositionVector2D.h:35
PositionVector2D.h:36
PositionVector2D.h:37
PositionVector2D.h:38
PositionVector2D.h:39
PositionVector2D.h:40
PositionVector2D.h:41
PositionVector2D.h:42
PositionVector2D.h:43
PositionVector2D.h:44
PositionVector2D.h:45
PositionVector2D.h:46
PositionVector2D.h:47
PositionVector2D.h:48
PositionVector2D.h:49
PositionVector2D.h:50
PositionVector2D.h:51
PositionVector2D.h:52
PositionVector2D.h:53
PositionVector2D.h:54
PositionVector2D.h:55
PositionVector2D.h:56
PositionVector2D.h:57
PositionVector2D.h:58
PositionVector2D.h:59
PositionVector2D.h:60
PositionVector2D.h:61
PositionVector2D.h:62
PositionVector2D.h:63
PositionVector2D.h:64
PositionVector2D.h:65
PositionVector2D.h:66
PositionVector2D.h:67
PositionVector2D.h:68
PositionVector2D.h:69
PositionVector2D.h:70
PositionVector2D.h:71
PositionVector2D.h:72
PositionVector2D.h:73
PositionVector2D.h:74
PositionVector2D.h:75
PositionVector2D.h:76
PositionVector2D.h:77
PositionVector2D.h:78
PositionVector2D.h:79
PositionVector2D.h:80
PositionVector2D.h:81
PositionVector2D.h:82
PositionVector2D.h:83
PositionVector2D.h:84
PositionVector2D.h:85
PositionVector2D.h:86
PositionVector2D.h:87
PositionVector2D.h:88
PositionVector2D.h:89
PositionVector2D.h:90
PositionVector2D.h:91
PositionVector2D.h:92
PositionVector2D.h:93
PositionVector2D.h:94
PositionVector2D.h:95
PositionVector2D.h:96
PositionVector2D.h:97
PositionVector2D.h:98
PositionVector2D.h:99
PositionVector2D.h:100
PositionVector2D.h:101
PositionVector2D.h:102
PositionVector2D.h:103
PositionVector2D.h:104
PositionVector2D.h:105
PositionVector2D.h:106
PositionVector2D.h:107
PositionVector2D.h:108
PositionVector2D.h:109
PositionVector2D.h:110
PositionVector2D.h:111
PositionVector2D.h:112
PositionVector2D.h:113
PositionVector2D.h:114
PositionVector2D.h:115
PositionVector2D.h:116
PositionVector2D.h:117
PositionVector2D.h:118
PositionVector2D.h:119
PositionVector2D.h:120
PositionVector2D.h:121
PositionVector2D.h:122
PositionVector2D.h:123
PositionVector2D.h:124
PositionVector2D.h:125
PositionVector2D.h:126
PositionVector2D.h:127
PositionVector2D.h:128
PositionVector2D.h:129
PositionVector2D.h:130
PositionVector2D.h:131
PositionVector2D.h:132
PositionVector2D.h:133
PositionVector2D.h:134
PositionVector2D.h:135
PositionVector2D.h:136
PositionVector2D.h:137
PositionVector2D.h:138
PositionVector2D.h:139
PositionVector2D.h:140
PositionVector2D.h:141
PositionVector2D.h:142
PositionVector2D.h:143
PositionVector2D.h:144
PositionVector2D.h:145
PositionVector2D.h:146
PositionVector2D.h:147
PositionVector2D.h:148
PositionVector2D.h:149
PositionVector2D.h:150
PositionVector2D.h:151
PositionVector2D.h:152
PositionVector2D.h:153
PositionVector2D.h:154
PositionVector2D.h:155
PositionVector2D.h:156
PositionVector2D.h:157
PositionVector2D.h:158
PositionVector2D.h:159
PositionVector2D.h:160
PositionVector2D.h:161
PositionVector2D.h:162
PositionVector2D.h:163
PositionVector2D.h:164
PositionVector2D.h:165
PositionVector2D.h:166
PositionVector2D.h:167
PositionVector2D.h:168
PositionVector2D.h:169
PositionVector2D.h:170
PositionVector2D.h:171
PositionVector2D.h:172
PositionVector2D.h:173
PositionVector2D.h:174
PositionVector2D.h:175
PositionVector2D.h:176
PositionVector2D.h:177
PositionVector2D.h:178
PositionVector2D.h:179
PositionVector2D.h:180
PositionVector2D.h:181
PositionVector2D.h:182
PositionVector2D.h:183
PositionVector2D.h:184
PositionVector2D.h:185
PositionVector2D.h:186
PositionVector2D.h:187
PositionVector2D.h:188
PositionVector2D.h:189
PositionVector2D.h:190
PositionVector2D.h:191
PositionVector2D.h:192
PositionVector2D.h:193
PositionVector2D.h:194
PositionVector2D.h:195
PositionVector2D.h:196
PositionVector2D.h:197
PositionVector2D.h:198
PositionVector2D.h:199
PositionVector2D.h:200
PositionVector2D.h:201
PositionVector2D.h:202
PositionVector2D.h:203
PositionVector2D.h:204
PositionVector2D.h:205
PositionVector2D.h:206
PositionVector2D.h:207
PositionVector2D.h:208
PositionVector2D.h:209
PositionVector2D.h:210
PositionVector2D.h:211
PositionVector2D.h:212
PositionVector2D.h:213
PositionVector2D.h:214
PositionVector2D.h:215
PositionVector2D.h:216
PositionVector2D.h:217
PositionVector2D.h:218
PositionVector2D.h:219
PositionVector2D.h:220
PositionVector2D.h:221
PositionVector2D.h:222
PositionVector2D.h:223
PositionVector2D.h:224
PositionVector2D.h:225
PositionVector2D.h:226
PositionVector2D.h:227
PositionVector2D.h:228
PositionVector2D.h:229
PositionVector2D.h:230
PositionVector2D.h:231
PositionVector2D.h:232
PositionVector2D.h:233
PositionVector2D.h:234
PositionVector2D.h:235
PositionVector2D.h:236
PositionVector2D.h:237
PositionVector2D.h:238
PositionVector2D.h:239
PositionVector2D.h:240
PositionVector2D.h:241
PositionVector2D.h:242
PositionVector2D.h:243
PositionVector2D.h:244
PositionVector2D.h:245
PositionVector2D.h:246
PositionVector2D.h:247
PositionVector2D.h:248
PositionVector2D.h:249
PositionVector2D.h:250
PositionVector2D.h:251
PositionVector2D.h:252
PositionVector2D.h:253
PositionVector2D.h:254
PositionVector2D.h:255
PositionVector2D.h:256
PositionVector2D.h:257
PositionVector2D.h:258
PositionVector2D.h:259
PositionVector2D.h:260
PositionVector2D.h:261
PositionVector2D.h:262
PositionVector2D.h:263
PositionVector2D.h:264
PositionVector2D.h:265
PositionVector2D.h:266
PositionVector2D.h:267
PositionVector2D.h:268
PositionVector2D.h:269
PositionVector2D.h:270
PositionVector2D.h:271
PositionVector2D.h:272
PositionVector2D.h:273
PositionVector2D.h:274
PositionVector2D.h:275
PositionVector2D.h:276
PositionVector2D.h:277
PositionVector2D.h:278
PositionVector2D.h:279
PositionVector2D.h:280
PositionVector2D.h:281
PositionVector2D.h:282
PositionVector2D.h:283
PositionVector2D.h:284
PositionVector2D.h:285
PositionVector2D.h:286
PositionVector2D.h:287
PositionVector2D.h:288
PositionVector2D.h:289
PositionVector2D.h:290
PositionVector2D.h:291
PositionVector2D.h:292
PositionVector2D.h:293
PositionVector2D.h:294
PositionVector2D.h:295
PositionVector2D.h:296
PositionVector2D.h:297
PositionVector2D.h:298
PositionVector2D.h:299
PositionVector2D.h:300
PositionVector2D.h:301
PositionVector2D.h:302
PositionVector2D.h:303
PositionVector2D.h:304
PositionVector2D.h:305
PositionVector2D.h:306
PositionVector2D.h:307
PositionVector2D.h:308
PositionVector2D.h:309
PositionVector2D.h:310
PositionVector2D.h:311
PositionVector2D.h:312
PositionVector2D.h:313
PositionVector2D.h:314
PositionVector2D.h:315
PositionVector2D.h:316
PositionVector2D.h:317
PositionVector2D.h:318
PositionVector2D.h:319
PositionVector2D.h:320
PositionVector2D.h:321
PositionVector2D.h:322
PositionVector2D.h:323
PositionVector2D.h:324
PositionVector2D.h:325
PositionVector2D.h:326
PositionVector2D.h:327
PositionVector2D.h:328
PositionVector2D.h:329
PositionVector2D.h:330
PositionVector2D.h:331
PositionVector2D.h:332
PositionVector2D.h:333
PositionVector2D.h:334
PositionVector2D.h:335
PositionVector2D.h:336
PositionVector2D.h:337
PositionVector2D.h:338
PositionVector2D.h:339
PositionVector2D.h:340
PositionVector2D.h:341
PositionVector2D.h:342
PositionVector2D.h:343
PositionVector2D.h:344
PositionVector2D.h:345
PositionVector2D.h:346
PositionVector2D.h:347
PositionVector2D.h:348
PositionVector2D.h:349
PositionVector2D.h:350
PositionVector2D.h:351
PositionVector2D.h:352
PositionVector2D.h:353
PositionVector2D.h:354
PositionVector2D.h:355
PositionVector2D.h:356
PositionVector2D.h:357
PositionVector2D.h:358
PositionVector2D.h:359
PositionVector2D.h:360
PositionVector2D.h:361
PositionVector2D.h:362
PositionVector2D.h:363
PositionVector2D.h:364
PositionVector2D.h:365
PositionVector2D.h:366
PositionVector2D.h:367
PositionVector2D.h:368
PositionVector2D.h:369
PositionVector2D.h:370
PositionVector2D.h:371
PositionVector2D.h:372
PositionVector2D.h:373
PositionVector2D.h:374
PositionVector2D.h:375
PositionVector2D.h:376
PositionVector2D.h:377
PositionVector2D.h:378
PositionVector2D.h:379
PositionVector2D.h:380
PositionVector2D.h:381
PositionVector2D.h:382
PositionVector2D.h:383
PositionVector2D.h:384
PositionVector2D.h:385
PositionVector2D.h:386
PositionVector2D.h:387
PositionVector2D.h:388
PositionVector2D.h:389
PositionVector2D.h:390
PositionVector2D.h:391
PositionVector2D.h:392
PositionVector2D.h:393
PositionVector2D.h:394
PositionVector2D.h:395
PositionVector2D.h:396
PositionVector2D.h:397
PositionVector2D.h:398
PositionVector2D.h:399
PositionVector2D.h:400
PositionVector2D.h:401
PositionVector2D.h:402
PositionVector2D.h:403
PositionVector2D.h:404
PositionVector2D.h:405
PositionVector2D.h:406
PositionVector2D.h:407
PositionVector2D.h:408
PositionVector2D.h:409
PositionVector2D.h:410
PositionVector2D.h:411
PositionVector2D.h:412
PositionVector2D.h:413
PositionVector2D.h:414
PositionVector2D.h:415
PositionVector2D.h:416
PositionVector2D.h:417
PositionVector2D.h:418
PositionVector2D.h:419
PositionVector2D.h:420
PositionVector2D.h:421
PositionVector2D.h:422
PositionVector2D.h:423
PositionVector2D.h:424
PositionVector2D.h:425
PositionVector2D.h:426
PositionVector2D.h:427
PositionVector2D.h:428
PositionVector2D.h:429
PositionVector2D.h:430
PositionVector2D.h:431
PositionVector2D.h:432
PositionVector2D.h:433
PositionVector2D.h:434
PositionVector2D.h:435
PositionVector2D.h:436
PositionVector2D.h:437
PositionVector2D.h:438
PositionVector2D.h:439
PositionVector2D.h:440
PositionVector2D.h:441
PositionVector2D.h:442
PositionVector2D.h:443
PositionVector2D.h:444
PositionVector2D.h:445
PositionVector2D.h:446
PositionVector2D.h:447
PositionVector2D.h:448
PositionVector2D.h:449
PositionVector2D.h:450
PositionVector2D.h:451
PositionVector2D.h:452
PositionVector2D.h:453
PositionVector2D.h:454
PositionVector2D.h:455
PositionVector2D.h:456
PositionVector2D.h:457
PositionVector2D.h:458
PositionVector2D.h:459
PositionVector2D.h:460
PositionVector2D.h:461
PositionVector2D.h:462
PositionVector2D.h:463
PositionVector2D.h:464
PositionVector2D.h:465
PositionVector2D.h:466
PositionVector2D.h:467
PositionVector2D.h:468
PositionVector2D.h:469
PositionVector2D.h:470
PositionVector2D.h:471
PositionVector2D.h:472
PositionVector2D.h:473
PositionVector2D.h:474
PositionVector2D.h:475
PositionVector2D.h:476
PositionVector2D.h:477
PositionVector2D.h:478
PositionVector2D.h:479
PositionVector2D.h:480
PositionVector2D.h:481
PositionVector2D.h:482
PositionVector2D.h:483
PositionVector2D.h:484
PositionVector2D.h:485
PositionVector2D.h:486
PositionVector2D.h:487
PositionVector2D.h:488
PositionVector2D.h:489
PositionVector2D.h:490
PositionVector2D.h:491
PositionVector2D.h:492
PositionVector2D.h:493
PositionVector2D.h:494
PositionVector2D.h:495
PositionVector2D.h:496
PositionVector2D.h:497
PositionVector2D.h:498
PositionVector2D.h:499
PositionVector2D.h:500
PositionVector2D.h:501
PositionVector2D.h:502
PositionVector2D.h:503
PositionVector2D.h:504
PositionVector2D.h:505
PositionVector2D.h:506
PositionVector2D.h:507
PositionVector2D.h:508
PositionVector2D.h:509
PositionVector2D.h:510
PositionVector2D.h:511
PositionVector2D.h:512
PositionVector2D.h:513
PositionVector2D.h:514
PositionVector2D.h:515
PositionVector2D.h:516
PositionVector2D.h:517