// @(#)root/mathcore:$Id: 9ef2a4a7bd1b62c1293920c2af2f64791c75bdd8$
// Authors: W. Brown, M. Fischler, L. Moneta    2005

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

// Header file for Vector Utility functions
//
// Created by: moneta  at Tue May 31 21:10:29 2005
//
// Last update: Tue May 31 21:10:29 2005
//
#ifndef ROOT_Math_GenVector_VectorUtil
#define ROOT_Math_GenVector_VectorUtil  1

#ifndef ROOT_Math_Math
#include "Math/Math.h"
#endif

#include "Math/GenVector/Boost.h"

namespace ROOT {

namespace Math {

// utility functions for vector classes

/**
Global Helper functions for generic Vector classes. Any Vector classes implementing some defined member functions,
like  Phi() or Eta() or mag() can use these functions.
The functions returning a scalar value, returns always double precision number even if the vector are
based on another precision type

@ingroup GenVector
*/

namespace VectorUtil {

// methods for 3D vectors

/**
Find aximutal Angle difference between two generic vectors ( v2.Phi() - v1.Phi() )
The only requirements on the Vector classes is that they implement the Phi() method
\param v1  Vector of any type implementing the Phi() operator
\param v2  Vector of any type implementing the Phi() operator
\return  Phi difference
\f[ \Delta \phi = \phi_2 - \phi_1 \f]
*/
template <class Vector1, class Vector2>
inline typename Vector1::Scalar DeltaPhi( const Vector1 & v1, const Vector2 & v2) {
typename Vector1::Scalar dphi = v2.Phi() - v1.Phi();
if ( dphi > M_PI ) {
dphi -= 2.0*M_PI;
} else if ( dphi <= -M_PI ) {
dphi += 2.0*M_PI;
}
return dphi;
}

/**
Find square of the difference in pseudorapidity (Eta) and Phi betwen two generic vectors
The only requirements on the Vector classes is that they implement the Phi() and Eta() method
\param v1  Vector 1
\param v2  Vector 2
\return   Angle between the two vectors
\f[ \Delta R2 = ( \Delta \phi )^2 + ( \Delta \eta )^2  \f]
*/
template <class Vector1, class Vector2>
inline typename Vector1::Scalar DeltaR2( const Vector1 & v1, const Vector2 & v2) {
typename Vector1::Scalar dphi = DeltaPhi(v1,v2);
typename Vector1::Scalar deta = v2.Eta() - v1.Eta();
return dphi*dphi + deta*deta;
}

/**
Find difference in pseudorapidity (Eta) and Phi betwen two generic vectors
The only requirements on the Vector classes is that they implement the Phi() and Eta() method
\param v1  Vector 1
\param v2  Vector 2
\return   Angle between the two vectors
\f[ \Delta R = \sqrt{  ( \Delta \phi )^2 + ( \Delta \eta )^2 } \f]
*/
template <class Vector1, class Vector2>
inline typename Vector1::Scalar DeltaR( const Vector1 & v1, const Vector2 & v2) {
return std::sqrt( DeltaR2(v1,v2) );
}

/**
Find CosTheta Angle between two generic 3D vectors
pre-requisite: vectors implement the X(), Y() and Z()
\param v1  Vector v1
\param v2  Vector v2
\return   cosine of Angle between the two vectors
\f[ \cos \theta = \frac { \vec{v1} \cdot \vec{v2} }{ | \vec{v1} | | \vec{v2} | } \f]
*/
// this cannot be made all generic since Mag2() for 2, 3 or 4 D is different
// need to have a specialization for polar Coordinates ??
template <class Vector1, class Vector2>
double CosTheta( const Vector1 &  v1, const Vector2  & v2) {
double arg;
double v1_r2 = v1.X()*v1.X() + v1.Y()*v1.Y() + v1.Z()*v1.Z();
double v2_r2 = v2.X()*v2.X() + v2.Y()*v2.Y() + v2.Z()*v2.Z();
double ptot2 = v1_r2*v2_r2;
if(ptot2 <= 0) {
arg = 0.0;
}else{
double pdot = v1.X()*v2.X() + v1.Y()*v2.Y() + v1.Z()*v2.Z();
arg = pdot/std::sqrt(ptot2);
if(arg >  1.0) arg =  1.0;
if(arg < -1.0) arg = -1.0;
}
return arg;
}

/**
Find Angle between two vectors.
Use the CosTheta() function
\param v1  Vector v1
\param v2  Vector v2
\return   Angle between the two vectors
\f[ \theta = \cos ^{-1} \frac { \vec{v1} \cdot \vec{v2} }{ | \vec{v1} | | \vec{v2} | } \f]
*/
template <class Vector1, class Vector2>
inline double Angle( const  Vector1 & v1, const Vector2 & v2) {
return std::acos( CosTheta(v1, v2) );
}

/**
Find the projection of v along the given direction u.
\param v  Vector v for which the propjection is to be found
\param u  Vector specifying the direction
\return   Vector projection (same type of v)
\f[ \vec{proj} = \frac{ \vec{v}  \cdot \vec{u} }{|\vec{u}|}\vec{u} \f]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()
*/
template <class Vector1, class Vector2>
Vector1 ProjVector( const  Vector1 & v, const Vector2 & u) {
double magU2 = u.X()*u.X() + u.Y()*u.Y() + u.Z()*u.Z();
if (magU2 == 0) return Vector1(0,0,0);
double d = v.Dot(u)/magU2;
return Vector1( u.X() * d, u.Y() * d, u.Z() * d);
}

/**
Find the vector component of v perpendicular to the given direction of u
\param v  Vector v for which the perpendicular component is to be found
\param u  Vector specifying the direction
\return   Vector component of v which is perpendicular to u
\f[ \vec{perp} = \vec{v} -  \frac{ \vec{v}  \cdot \vec{u} }{|\vec{u}|}\vec{u} \f]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()
*/
template <class Vector1, class Vector2>
inline Vector1 PerpVector( const  Vector1 & v, const Vector2 & u) {
return v - ProjVector(v,u);
}

/**
Find the magnitude square of the vector component of v perpendicular to the given direction of u
\param v  Vector v for which the perpendicular component is to be found
\param u  Vector specifying the direction
\return   square value of the component of v which is perpendicular to u
\f[ perp = | \vec{v} -  \frac{ \vec{v}  \cdot \vec{u} }{|\vec{u}|}\vec{u} |^2 \f]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()
*/
template <class Vector1, class Vector2>
inline double Perp2( const  Vector1 & v, const Vector2 & u) {
double magU2 = u.X()*u.X() + u.Y()*u.Y() + u.Z()*u.Z();
double prjvu = v.Dot(u);
double magV2 = v.Dot(v);
return magU2 > 0.0 ? magV2-prjvu*prjvu/magU2 : magV2;
}

/**
Find the magnitude of the vector component of v perpendicular to the given direction of u
\param v  Vector v for which the perpendicular component is to be found
\param u  Vector specifying the direction
\return   value of the component of v which is perpendicular to u
\f[ perp = | \vec{v} -  \frac{ \vec{v}  \cdot \vec{u} }{|\vec{u}|}\vec{u} | \f]
Precondition is that Vector1 implements Dot function and Vector2 implements X(),Y() and Z()
*/
template <class Vector1, class Vector2>
inline double Perp( const  Vector1 & v, const Vector2 & u) {
return std::sqrt(Perp2(v,u) );
}

// Lorentz Vector functions

/**
return the invariant mass of two LorentzVector
The only requirement on the LorentzVector is that they need to implement the
X() , Y(), Z() and E() methods.
\param v1 LorenzVector 1
\param v2 LorenzVector 2
\return invariant mass M
\f[ M_{12} = \sqrt{ (\vec{v1} + \vec{v2} ) \cdot (\vec{v1} + \vec{v2} ) } \f]
*/
template <class Vector1, class Vector2>
inline typename Vector1::Scalar InvariantMass( const Vector1 & v1, const Vector2 & v2) {
typedef typename  Vector1::Scalar Scalar;
Scalar ee = (v1.E() + v2.E() );
Scalar xx = (v1.X() + v2.X() );
Scalar yy = (v1.Y() + v2.Y() );
Scalar zz = (v1.Z() + v2.Z() );
Scalar mm2 = ee*ee - xx*xx - yy*yy - zz*zz;
return mm2 < 0.0 ? -std::sqrt(-mm2) : std::sqrt(mm2);
//  PxPyPzE4D<double> q(xx,yy,zz,ee);
//  return q.M();
//return ( v1 + v2).mag();
}

template <class Vector1, class Vector2>
inline typename Vector1::Scalar InvariantMass2( const Vector1 & v1, const Vector2 & v2) {
typedef typename  Vector1::Scalar Scalar;
Scalar ee = (v1.E() + v2.E() );
Scalar xx = (v1.X() + v2.X() );
Scalar yy = (v1.Y() + v2.Y() );
Scalar zz = (v1.Z() + v2.Z() );
Scalar mm2 = ee*ee - xx*xx - yy*yy - zz*zz;
return mm2 ; // < 0.0 ? -std::sqrt(-mm2) : std::sqrt(mm2);
//  PxPyPzE4D<double> q(xx,yy,zz,ee);
//  return q.M();
//return ( v1 + v2).mag();
}

// rotation and transformations

#ifndef __CINT__
/**
rotation along X axis for a generic vector by an Angle alpha
returning a new vector.
The only pre requisite on the Vector is that it has to implement the X() , Y() and Z()
and SetXYZ methods.
*/
template <class Vector>
Vector RotateX(const Vector & v, double alpha) {
double sina = sin(alpha);
double cosa = cos(alpha);
double y2 = v.Y() * cosa - v.Z()*sina;
double z2 = v.Z() * cosa + v.Y() * sina;
Vector vrot;
vrot.SetXYZ(v.X(), y2, z2);
return vrot;
}

/**
rotation along Y axis for a generic vector by an Angle alpha
returning a new vector.
The only pre requisite on the Vector is that it has to implement the X() , Y() and Z()
and SetXYZ methods.
*/
template <class Vector>
Vector RotateY(const Vector & v, double alpha) {
double sina = sin(alpha);
double cosa = cos(alpha);
double x2 = v.X() * cosa + v.Z() * sina;
double z2 = v.Z() * cosa - v.X() * sina;
Vector vrot;
vrot.SetXYZ(x2, v.Y(), z2);
return vrot;
}

/**
rotation along Z axis for a generic vector by an Angle alpha
returning a new vector.
The only pre requisite on the Vector is that it has to implement the X() , Y() and Z()
and SetXYZ methods.
*/
template <class Vector>
Vector RotateZ(const Vector & v, double alpha) {
double sina = sin(alpha);
double cosa = cos(alpha);
double x2 = v.X() * cosa - v.Y() * sina;
double y2 = v.Y() * cosa + v.X() * sina;
Vector vrot;
vrot.SetXYZ(x2, y2, v.Z());
return vrot;
}

/**
rotation on a generic vector using a generic rotation class.
The only requirement on the vector is that implements the
X(), Y(), Z() and SetXYZ methods.
The requirement on the rotation matrix is that need to implement the
(i,j) operator returning the matrix element with R(0,0) = xx element
*/
template<class Vector, class RotationMatrix>
Vector Rotate(const Vector &v, const RotationMatrix & rot) {
double xX = v.X();
double yY = v.Y();
double zZ = v.Z();
double x2 =  rot(0,0)*xX + rot(0,1)*yY + rot(0,2)*zZ;
double y2 =  rot(1,0)*xX + rot(1,1)*yY + rot(1,2)*zZ;
double z2 =  rot(2,0)*xX + rot(2,1)*yY + rot(2,2)*zZ;
Vector vrot;
vrot.SetXYZ(x2,y2,z2);
return vrot;
}

/**
Boost a generic Lorentz Vector class using a generic 3D Vector class describing the boost
The only requirement on the vector is that implements the
X(), Y(), Z(), T() and SetXYZT methods.
The requirement on the boost vector is that needs to implement the
X(), Y() , Z()  retorning the vector elements describing the boost
The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned
*/
template <class LVector, class BoostVector>
LVector boost(const LVector & v, const BoostVector & b) {
double bx = b.X();
double by = b.Y();
double bz = b.Z();
double b2 = bx*bx + by*by + bz*bz;
if (b2 >= 1) {
GenVector::Throw ( "Beta Vector supplied to set Boost represents speed >= c");
return LVector();
}
double gamma = 1.0 / std::sqrt(1.0 - b2);
double bp = bx*v.X() + by*v.Y() + bz*v.Z();
double gamma2 = b2 > 0 ? (gamma - 1.0)/b2 : 0.0;
double x2 = v.X() + gamma2*bp*bx + gamma*bx*v.T();
double y2 = v.Y() + gamma2*bp*by + gamma*by*v.T();
double z2 = v.Z() + gamma2*bp*bz + gamma*bz*v.T();
double t2 = gamma*(v.T() + bp);
LVector lv;
lv.SetXYZT(x2,y2,z2,t2);
return lv;
}

/**
Boost a generic Lorentz Vector class along the X direction with a factor beta
The only requirement on the vector is that implements the
X(), Y(), Z(), T()  and SetXYZT methods.
The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned
*/
template <class LVector, class T>
LVector boostX(const LVector & v, T beta) {
if (beta >= 1) {
GenVector::Throw ("Beta Vector supplied to set Boost represents speed >= c");
return LVector();
}
T gamma = 1.0/ std::sqrt(1.0 - beta*beta);
typename LVector::Scalar x2 = gamma * v.X() + gamma * beta * v.T();
typename LVector::Scalar t2 = gamma * beta * v.X() + gamma * v.T();

LVector lv;
lv.SetXYZT(x2,v.Y(),v.Z(),t2);
return lv;
}

/**
Boost a generic Lorentz Vector class along the Y direction with a factor beta
The only requirement on the vector is that implements the
X(), Y(), Z(), T()  methods and be constructed from x,y,z,t values
The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned
*/
template <class LVector>
LVector boostY(const LVector & v, double beta) {
if (beta >= 1) {
GenVector::Throw ("Beta Vector supplied to set Boost represents speed >= c");
return LVector();
}
double gamma = 1.0/ std::sqrt(1.0 - beta*beta);
double y2 = gamma * v.Y() + gamma * beta * v.T();
double t2 = gamma * beta * v.Y() + gamma * v.T();
LVector lv;
lv.SetXYZT(v.X(),y2,v.Z(),t2);
return lv;
}

/**
Boost a generic Lorentz Vector class along the Z direction with a factor beta
The only requirement on the vector is that implements the
X(), Y(), Z(), T()  methods and be constructed from x,y,z,t values
The beta of the boost must be <= 1 or a nul Lorentz Vector will be returned
*/
template <class LVector>
LVector boostZ(const LVector & v, double beta) {
if (beta >= 1) {
GenVector::Throw ( "Beta Vector supplied to set Boost represents speed >= c");
return LVector();
}
double gamma = 1.0/ std::sqrt(1.0 - beta*beta);
double z2 = gamma * v.Z() + gamma * beta * v.T();
double t2 = gamma * beta * v.Z() + gamma * v.T();
LVector lv;
lv.SetXYZT(v.X(),v.Y(),z2,t2);
return lv;
}

#endif

// MATRIX VECTOR MULTIPLICATION
// cannot define an operator * otherwise conflicts with rotations
// operations like Rotation3D * vector use Mult

/**
Multiplications of a generic matrices with a  DisplacementVector3D of any coordinate system.
Assume that the matrix implements the operator( i,j) and that it has at least         3 columns and 3 rows. There is no check on the matrix size !!
*/
template<class Matrix, class CoordSystem, class U>
inline
DisplacementVector3D<CoordSystem,U> Mult (const Matrix & m, const DisplacementVector3D<CoordSystem,U> & v) {
DisplacementVector3D<CoordSystem,U> vret;
vret.SetXYZ( m(0,0) * v.x() + m(0,1) * v.y() + m(0,2) * v.z() ,
m(1,0) * v.x() + m(1,1) * v.y() + m(1,2) * v.z() ,
m(2,0) * v.x() + m(2,1) * v.y() + m(2,2) * v.z() );
return vret;
}

/**
Multiplications of a generic matrices with a generic PositionVector
Assume that the matrix implements the operator( i,j) and that it has at least         3 columns and 3 rows. There is no check on the matrix size !!
*/
template<class Matrix, class CoordSystem, class U>
inline
PositionVector3D<CoordSystem,U> Mult (const Matrix & m, const PositionVector3D<CoordSystem,U> & p) {
DisplacementVector3D<CoordSystem,U> pret;
pret.SetXYZ( m(0,0) * p.x() + m(0,1) * p.y() + m(0,2) * p.z() ,
m(1,0) * p.x() + m(1,1) * p.y() + m(1,2) * p.z() ,
m(2,0) * p.x() + m(2,1) * p.y() + m(2,2) * p.z() );
return pret;
}

/**
Multiplications of a generic matrices with a  LorentzVector described
in any coordinate system.
Assume that the matrix implements the operator( i,j) and that it has at least         4 columns and 4 rows. There is no check on the matrix size !!
*/
// this will not be ambigous with operator*(Scalar, LorentzVector) since that one     // Scalar is passed by value
template<class CoordSystem, class Matrix>
inline
LorentzVector<CoordSystem> Mult (const Matrix & m, const LorentzVector<CoordSystem> & v) {
LorentzVector<CoordSystem> vret;
vret.SetXYZT( m(0,0)*v.x() + m(0,1)*v.y() + m(0,2)*v.z() + m(0,3)* v.t() ,
m(1,0)*v.x() + m(1,1)*v.y() + m(1,2)*v.z() + m(1,3)* v.t() ,
m(2,0)*v.x() + m(2,1)*v.y() + m(2,2)*v.z() + m(2,3)* v.t() ,
m(3,0)*v.x() + m(3,1)*v.y() + m(3,2)*v.z() + m(3,3)* v.t() );
return vret;
}

// non-template utility functions for all objects

/**
Return a phi angle in the interval (0,2*PI]
*/
double Phi_0_2pi(double phi);
/**
Returns phi angle in the interval (-PI,PI]
*/
double  Phi_mpi_pi(double phi);

}  // end namespace Vector Util

} // end namespace Math

} // end namespace ROOT

#endif /* ROOT_Math_GenVector_VectorUtil  */

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