// @(#)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