CMS 3D CMS Logo
Public Types | Public Member Functions | Public Attributes | Private Attributes

Basic2DVector< T > Class Template Reference

#include <newBasic2DVector.h>

List of all members.

Public Types

typedef mathSSE::Vec2< T > MathVector
typedef Basic2DVector< T > MathVector
typedef Geom::Polar2Cartesian< T > Polar
typedef Geom::Polar2Cartesian< T > Polar
typedef T ScalarType
typedef T ScalarType
typedef mathSSE::Vec2< T > VectorType

Public Member Functions

T barePhi () const
T barePhi () const
 Basic2DVector (const Basic2DVector &p)
 Copy constructor from same type. Should not be needed but for gcc bug 12685.
template<typename U >
 Basic2DVector (mathSSE::Vec4< U > const &iv)
template<class Other >
 Basic2DVector (const Other &p)
 Basic2DVector (const T &x, const T &y)
 construct from cartesian coordinates
 Basic2DVector ()
template<typename U >
 Basic2DVector (mathSSE::Vec2< U > const &iv)
 Basic2DVector ()
template<typename U >
 Basic2DVector (const Basic2DVector< U > &p)
 Basic2DVector (const Basic2DVector &p)
 Copy constructor from same type. Should not be needed but for gcc bug 12685.
template<class Other >
 Basic2DVector (const Other &p)
template<typename U >
 Basic2DVector (mathSSE::Vec4< U > const &iv)
 Basic2DVector (const T &x, const T &y)
 construct from cartesian coordinates
template<typename U >
 Basic2DVector (mathSSE::Vec2< U > const &iv)
template<class U >
PreciseFloatType< T, U >::Type cross (const Basic2DVector< U > &v) const
T cross (const Basic2DVector &lh) const
 Vector product, or "cross" product, with a vector of same type.
T cross (const Basic2DVector &v) const
 Vector product, or "cross" product, with a vector of same type.
template<class U >
PreciseFloatType< T, U >::Type cross (const Basic2DVector< U > &lh) const
template<class U >
PreciseFloatType< T, U >::Type dot (const Basic2DVector< U > &v) const
T dot (const Basic2DVector &lh) const
 Scalar product, or "dot" product, with a vector of same type.
T dot (const Basic2DVector &v) const
 Scalar product, or "dot" product, with a vector of same type.
template<class U >
PreciseFloatType< T, U >::Type dot (const Basic2DVector< U > &lh) const
T mag () const
 The vector magnitude. Equivalent to sqrt(vec.mag2())
T mag () const
 The vector magnitude. Equivalent to sqrt(vec.mag2())
T mag2 () const
 The vector magnitude squared. Equivalent to vec.dot(vec)
T mag2 () const
 The vector magnitude squared. Equivalent to vec.dot(vec)
MathVector const & mathVector () const
MathVector & mathVector ()
Basic2DVector & operator*= (T t)
 Scaling by a scalar value (multiplication)
Basic2DVector & operator*= (const T &t)
 Scaling by a scalar value (multiplication)
template<class U >
Basic2DVector & operator+= (const Basic2DVector< U > &p)
template<class U >
Basic2DVector & operator+= (const Basic2DVector< U > &p)
Basic2DVector operator- () const
 Unary minus, returns a vector with components (-x(),-y(),-z())
Basic2DVector operator- () const
 Unary minus, returns a vector with components (-x(),-y(),-z())
template<class U >
Basic2DVector & operator-= (const Basic2DVector< U > &p)
template<class U >
Basic2DVector & operator-= (const Basic2DVector< U > &p)
Basic2DVector & operator/= (T t)
 Scaling by a scalar value (division)
Basic2DVector & operator/= (const T &t)
 Scaling by a scalar value (division)
Geom::Phi< T > phi () const
Geom::Phi< T > phi () const
T r () const
 Radius, same as mag()
T r () const
 Radius, same as mag()
Basic2DVector unit () const
Basic2DVector unit () const
T x () const
 Cartesian x coordinate.
T x () const
 Cartesian x coordinate.
T y () const
 Cartesian y coordinate.
T y () const
 Cartesian y coordinate.

Public Attributes

mathSSE::Vec2< T > v

Private Attributes

T theX
T theY

Detailed Description

template<class T>
class Basic2DVector< T >

Definition at line 15 of file newBasic2DVector.h.

Member Typedef Documentation

template<class T>
typedef mathSSE::Vec2<T> Basic2DVector< T >::MathVector

Definition at line 20 of file newBasic2DVector.h.

template<class T>
typedef Basic2DVector<T> Basic2DVector< T >::MathVector

Definition at line 22 of file oldBasic2DVector.h.

template<class T>
typedef Geom::Polar2Cartesian<T> Basic2DVector< T >::Polar

Definition at line 21 of file newBasic2DVector.h.

template<class T>
typedef Geom::Polar2Cartesian<T> Basic2DVector< T >::Polar

Definition at line 25 of file oldBasic2DVector.h.

template<class T>
typedef T Basic2DVector< T >::ScalarType

Definition at line 24 of file oldBasic2DVector.h.

template<class T>
typedef T Basic2DVector< T >::ScalarType

Definition at line 18 of file newBasic2DVector.h.

template<class T>
typedef mathSSE::Vec2<T> Basic2DVector< T >::VectorType

Definition at line 19 of file newBasic2DVector.h.

Constructor & Destructor Documentation

template<class T>
Basic2DVector< T >::Basic2DVector ( ) [inline]

default constructor uses default constructor of T to initialize the components. For built-in floating-point types this means initialization to zero

Definition at line 27 of file newBasic2DVector.h.

Referenced by Basic2DVector< TmpType >::operator-().

{}
template<class T>
Basic2DVector< T >::Basic2DVector ( const Basic2DVector< T > &  p) [inline]

Copy constructor from same type. Should not be needed but for gcc bug 12685.

Definition at line 30 of file newBasic2DVector.h.

: v(p.v) {}
template<class T>
template<typename U >
Basic2DVector< T >::Basic2DVector ( const Basic2DVector< U > &  p) [inline]

Definition at line 33 of file newBasic2DVector.h.

: v(p.v) {}
template<class T>
template<class Other >
Basic2DVector< T >::Basic2DVector ( const Other &  p) [inline, explicit]

Explicit constructor from other (possibly unrelated) vector classes The only constraint on the argument type is that it has methods x() and y(), and that these methods return a type convertible to T. Examples of use are
construction from a Basic2DVector with different precision
construction from a coordinate system converter

Definition at line 44 of file newBasic2DVector.h.

: v(p.x(),p.y()) {}
template<class T>
Basic2DVector< T >::Basic2DVector ( const T &  x,
const T &  y 
) [inline]

construct from cartesian coordinates

Definition at line 47 of file newBasic2DVector.h.

: v(x,y) {}
template<class T>
template<typename U >
Basic2DVector< T >::Basic2DVector ( mathSSE::Vec2< U > const &  iv) [inline]

Definition at line 51 of file newBasic2DVector.h.

: v(iv){}
template<class T>
template<typename U >
Basic2DVector< T >::Basic2DVector ( mathSSE::Vec4< U > const &  iv) [inline]

Definition at line 53 of file newBasic2DVector.h.

: v(iv.xy()){}
template<class T>
Basic2DVector< T >::Basic2DVector ( ) [inline]

default constructor uses default constructor of T to initialize the components. For built-in floating-point types this means initialization to zero

Definition at line 31 of file oldBasic2DVector.h.

: theX(0), theY(0) {}
template<class T>
Basic2DVector< T >::Basic2DVector ( const Basic2DVector< T > &  p) [inline]

Copy constructor from same type. Should not be needed but for gcc bug 12685.

Definition at line 34 of file oldBasic2DVector.h.

                                          : 
    theX(p.x()), theY(p.y()) {}
template<class T>
template<class Other >
Basic2DVector< T >::Basic2DVector ( const Other &  p) [inline, explicit]

Explicit constructor from other (possibly unrelated) vector classes The only constraint on the argument type is that it has methods x() and y(), and that these methods return a type convertible to T. Examples of use are
construction from a Basic2DVector with different precision
construction from a coordinate system converter

Definition at line 45 of file oldBasic2DVector.h.

: theX(p.x()), theY(p.y()) {}
template<class T>
Basic2DVector< T >::Basic2DVector ( const T &  x,
const T &  y 
) [inline]

construct from cartesian coordinates

Definition at line 48 of file oldBasic2DVector.h.

: theX(x), theY(y) {}
template<class T>
template<typename U >
Basic2DVector< T >::Basic2DVector ( mathSSE::Vec2< U > const &  iv) [inline]

Definition at line 54 of file oldBasic2DVector.h.

                                          :
    theX(iv.arr[0]), theY(iv.arr[1]) {}
template<class T>
template<typename U >
Basic2DVector< T >::Basic2DVector ( mathSSE::Vec4< U > const &  iv) [inline]

Definition at line 57 of file oldBasic2DVector.h.

                                          :
    theX(iv.arr[0]), theY(iv.arr[1]) {}

Member Function Documentation

template<class T>
T Basic2DVector< T >::barePhi ( ) const [inline]

Azimuthal angle. The value is returned in radians, in the range (-pi,pi]. Same precision as the system atan2(x,y) function. The return type is Geom::Phi<T>, see it's documentation.

Definition at line 78 of file newBasic2DVector.h.

Referenced by PV2DBase< double, PointTag, LocalTag >::barePhi().

{return std::atan2(y(),x());}
template<class T>
T Basic2DVector< T >::barePhi ( ) const [inline]

Azimuthal angle. The value is returned in radians, in the range (-pi,pi]. Same precision as the system atan2(x,y) function. The return type is Geom::Phi<T>, see it's documentation.

Definition at line 81 of file oldBasic2DVector.h.

{return std::atan2(theY,theX);}
template<class T>
T Basic2DVector< T >::cross ( const Basic2DVector< T > &  lh) const [inline]

Vector product, or "cross" product, with a vector of same type.

Definition at line 136 of file newBasic2DVector.h.

Referenced by Basic2DVector< TmpType >::cross().

{ return ::cross(v,lh.v);}
template<class T>
template<class U >
PreciseFloatType<T,U>::Type Basic2DVector< T >::cross ( const Basic2DVector< U > &  lh) const [inline]

Vector (or cross) product with a vector of different precision. The product is computed without loss of precision. The type of the returned scalar is the more precise of the scalar types of the two vectors.

Definition at line 144 of file newBasic2DVector.h.

                                                                              { 
    return Basic2DVector<typename PreciseFloatType<T,U>::Type>(*this)
      .cross(Basic2DVector<typename PreciseFloatType<T,U>::Type>(lh));
  }
template<class T>
T Basic2DVector< T >::cross ( const Basic2DVector< T > &  v) const [inline]

Vector product, or "cross" product, with a vector of same type.

Definition at line 143 of file oldBasic2DVector.h.

{ return x()*v.y() - y()*v.x();}
template<class T>
template<class U >
PreciseFloatType<T,U>::Type Basic2DVector< T >::cross ( const Basic2DVector< U > &  v) const [inline]

Vector (or cross) product with a vector of different precision. The product is computed without loss of precision. The type of the returned scalar is the more precise of the scalar types of the two vectors.

Definition at line 151 of file oldBasic2DVector.h.

                                                                             { 
    return x()*v.y() - y()*v.x();
  }
template<class T>
template<class U >
PreciseFloatType<T,U>::Type Basic2DVector< T >::dot ( const Basic2DVector< U > &  v) const [inline]

Scalar (or dot) product with a vector of different precision. The product is computed without loss of precision. The type of the returned scalar is the more precise of the scalar types of the two vectors.

Definition at line 136 of file oldBasic2DVector.h.

                                                                           { 
    return x()*v.x() + y()*v.y();
  }
template<class T>
T Basic2DVector< T >::dot ( const Basic2DVector< T > &  v) const [inline]

Scalar product, or "dot" product, with a vector of same type.

Definition at line 128 of file oldBasic2DVector.h.

{ return x()*v.x() + y()*v.y();}
template<class T>
T Basic2DVector< T >::dot ( const Basic2DVector< T > &  lh) const [inline]

Scalar product, or "dot" product, with a vector of same type.

Definition at line 122 of file newBasic2DVector.h.

Referenced by Vector2DBase< float, GlobalTag >::dot(), Basic2DVector< TmpType >::dot(), Basic2DVector< TmpType >::mag2(), operator*(), and InnerDeltaPhi::phiRange().

{ return ::dot(v,lh.v);}
template<class T>
template<class U >
PreciseFloatType<T,U>::Type Basic2DVector< T >::dot ( const Basic2DVector< U > &  lh) const [inline]

Scalar (or dot) product with a vector of different precision. The product is computed without loss of precision. The type of the returned scalar is the more precise of the scalar types of the two vectors.

Definition at line 130 of file newBasic2DVector.h.

                                                                            { 
    return Basic2DVector<typename PreciseFloatType<T,U>::Type>(*this)
      .dot(Basic2DVector<typename PreciseFloatType<T,U>::Type>(lh));
  }
template<class T>
T Basic2DVector< T >::mag ( ) const [inline]

The vector magnitude. Equivalent to sqrt(vec.mag2())

Definition at line 69 of file newBasic2DVector.h.

Referenced by HelixBarrelCylinderCrossing::HelixBarrelCylinderCrossing(), ThirdHitPredictionFromCircle::invCenterOnAxis(), PV2DBase< double, PointTag, LocalTag >::mag(), HelixBarrelPlaneCrossingByCircle::pathLength(), InnerDeltaPhi::phiRange(), Basic2DVector< TmpType >::r(), TrackFitter::run(), PixelFitterByHelixProjections::run(), and Basic2DVector< TmpType >::unit().

{ return std::sqrt( mag2());}
template<class T>
T Basic2DVector< T >::mag ( ) const [inline]

The vector magnitude. Equivalent to sqrt(vec.mag2())

Definition at line 72 of file oldBasic2DVector.h.

{ return std::sqrt( mag2());}
template<class T>
T Basic2DVector< T >::mag2 ( ) const [inline]

The vector magnitude squared. Equivalent to vec.dot(vec)

Definition at line 69 of file oldBasic2DVector.h.

{ return theX*theX + theY*theY;}
template<class T>
T Basic2DVector< T >::mag2 ( ) const [inline]

The vector magnitude squared. Equivalent to vec.dot(vec)

Definition at line 66 of file newBasic2DVector.h.

Referenced by ThirdHitPredictionFromCircle::angle(), HelixBarrelCylinderCrossing::chooseSolution(), HelixBarrelPlaneCrossingByCircle::chooseSolution(), CircleFromThreePoints::init(), Basic2DVector< TmpType >::mag(), PV2DBase< double, PointTag, LocalTag >::mag2(), ConformalMappingFit::MappedPoint< T >::MappedPoint(), ThirdHitPredictionFromInvLine::MappedPoint< T >::MappedPoint(), ThirdHitPredictionFromCircle::phi(), ThirdHitPredictionFromInvParabola::transform(), ThirdHitPredictionFromInvParabola::transformBack(), and ThirdHitPredictionFromCircle::HelixRZ::zAtR().

{ return ::dot(v,v);}
template<class T>
MathVector const& Basic2DVector< T >::mathVector ( ) const [inline]

Definition at line 55 of file newBasic2DVector.h.

{ return v;}
template<class T>
MathVector& Basic2DVector< T >::mathVector ( ) [inline]

Definition at line 56 of file newBasic2DVector.h.

{ return v;}
template<class T>
Basic2DVector& Basic2DVector< T >::operator*= ( T  t) [inline]

Scaling by a scalar value (multiplication)

Definition at line 109 of file newBasic2DVector.h.

                                   {
    v = v*t;
    return *this;
  }
template<class T>
Basic2DVector& Basic2DVector< T >::operator*= ( const T &  t) [inline]

Scaling by a scalar value (multiplication)

Definition at line 114 of file oldBasic2DVector.h.

                                          {
    theX *= t;
    theY *= t;
    return *this;
  }
template<class T>
template<class U >
Basic2DVector& Basic2DVector< T >::operator+= ( const Basic2DVector< U > &  p) [inline]

Operator += with a Basic2DVector of possibly different precision.

Definition at line 92 of file newBasic2DVector.h.

                                                         {
    v = v + p.v;
    return *this;
  }
template<class T>
template<class U >
Basic2DVector& Basic2DVector< T >::operator+= ( const Basic2DVector< U > &  p) [inline]

Operator += with a Basic2DVector of possibly different precision.

Definition at line 95 of file oldBasic2DVector.h.

                                                         {
    theX += p.x();
    theY += p.y();
    return *this;
  }
template<class T>
Basic2DVector Basic2DVector< T >::operator- ( ) const [inline]

Unary minus, returns a vector with components (-x(),-y(),-z())

Definition at line 111 of file oldBasic2DVector.h.

{ return Basic2DVector(-x(),-y());}
template<class T>
Basic2DVector Basic2DVector< T >::operator- ( ) const [inline]

Unary minus, returns a vector with components (-x(),-y(),-z())

Definition at line 106 of file newBasic2DVector.h.

{ return Basic2DVector(-v);}
template<class T>
template<class U >
Basic2DVector& Basic2DVector< T >::operator-= ( const Basic2DVector< U > &  p) [inline]

Operator -= with a Basic2DVector of possibly different precision.

Definition at line 104 of file oldBasic2DVector.h.

                                                         {
    theX -= p.x();
    theY -= p.y();
    return *this;
  }
template<class T>
template<class U >
Basic2DVector& Basic2DVector< T >::operator-= ( const Basic2DVector< U > &  p) [inline]

Operator -= with a Basic2DVector of possibly different precision.

Definition at line 100 of file newBasic2DVector.h.

                                                         {
    v = v - p.v;
    return *this;
  }
template<class T>
Basic2DVector& Basic2DVector< T >::operator/= ( const T &  t) [inline]

Scaling by a scalar value (division)

Definition at line 121 of file oldBasic2DVector.h.

                                          {
    theX /= t;
    theY /= t;
    return *this;
  }
template<class T>
Basic2DVector& Basic2DVector< T >::operator/= ( T  t) [inline]

Scaling by a scalar value (division)

Definition at line 115 of file newBasic2DVector.h.

                                   {
    t = T(1)/t;
    v = v*t;
    return *this;
  }
template<class T>
Geom::Phi<T> Basic2DVector< T >::phi ( ) const [inline]

Definition at line 82 of file oldBasic2DVector.h.

{return Geom::Phi<T>(atan2(theY,theX));}
template<class T>
Geom::Phi<T> Basic2DVector< T >::phi ( ) const [inline]

Definition at line 79 of file newBasic2DVector.h.

Referenced by ThirdHitPredictionFromCircle::phi(), PV2DBase< double, PointTag, LocalTag >::phi(), and InnerDeltaPhi::phiRange().

{return Geom::Phi<T>(atan2(y(),x()));}
template<class T>
T Basic2DVector< T >::r ( ) const [inline]

Radius, same as mag()

Definition at line 72 of file newBasic2DVector.h.

Referenced by PixelTripletLargeTipGenerator::hitTriplets(), and PV2DBase< double, PointTag, LocalTag >::r().

{ return mag();}
template<class T>
T Basic2DVector< T >::r ( ) const [inline]

Radius, same as mag()

Definition at line 75 of file oldBasic2DVector.h.

{ return mag();}
template<class T>
Basic2DVector Basic2DVector< T >::unit ( ) const [inline]

Unit vector parallel to this. If mag() is zero, a zero vector is returned.

Definition at line 87 of file oldBasic2DVector.h.

                             {
    T my_mag = mag();
    return my_mag == 0 ? *this : *this / my_mag;
  }
template<class T>
Basic2DVector Basic2DVector< T >::unit ( ) const [inline]

Unit vector parallel to this. If mag() is zero, a zero vector is returned.

Definition at line 84 of file newBasic2DVector.h.

Referenced by InnerDeltaPhi::phiRange(), and TkRotation2D< double >::TkRotation2D().

                             {
    T my_mag = mag();
    return my_mag == 0 ? *this : *this / my_mag;
  }
template<class T>
T Basic2DVector< T >::x ( ) const [inline]

Cartesian x coordinate.

Definition at line 60 of file newBasic2DVector.h.

Referenced by Basic2DVector< TmpType >::barePhi(), HelixBarrelCylinderCrossing::chooseSolution(), HelixBarrelPlaneCrossingByCircle::chooseSolution(), Basic2DVector< TmpType >::cross(), ThirdHitPredictionFromInvLine::crossing(), ThirdHitPredictionFromCircle::curvature(), Basic2DVector< TmpType >::dot(), ConformalMappingFit::findRot(), HelixBarrelCylinderCrossing::HelixBarrelCylinderCrossing(), HelixBarrelPlaneCrossing2OrderLocal::HelixBarrelPlaneCrossing2OrderLocal(), ThirdHitPredictionFromInvParabola::init(), CircleFromThreePoints::init(), ThirdHitPredictionFromCircle::invCenterOnAxis(), TkRotation< align::Scalar >::multiplyInverse(), operator*(), TkRotation< align::Scalar >::operator*(), operator+(), Basic2DVector< TmpType >::operator+=(), operator-(), Basic2DVector< TmpType >::operator-(), Basic2DVector< TmpType >::operator-=(), operator/(), Basic2DVector< TmpType >::phi(), HelixBarrelPlaneCrossingByCircle::position(), ThirdHitPredictionFromCircle::HelixRZ::rAtZ(), TrackFitter::run(), PixelFitterByHelixProjections::run(), TkRotation2D< double >::TkRotation2D(), and PV2DBase< double, PointTag, LocalTag >::x().

{ return v[0];}
template<class T>
T Basic2DVector< T >::x ( ) const [inline]

Cartesian x coordinate.

Definition at line 63 of file oldBasic2DVector.h.

{ return theX;}
template<class T>
T Basic2DVector< T >::y ( ) const [inline]

Cartesian y coordinate.

Definition at line 63 of file newBasic2DVector.h.

Referenced by Basic2DVector< TmpType >::barePhi(), HelixBarrelCylinderCrossing::chooseSolution(), HelixBarrelPlaneCrossingByCircle::chooseSolution(), Basic2DVector< TmpType >::cross(), ThirdHitPredictionFromInvLine::crossing(), ThirdHitPredictionFromCircle::curvature(), Basic2DVector< TmpType >::dot(), ConformalMappingFit::findRot(), HelixBarrelCylinderCrossing::HelixBarrelCylinderCrossing(), HelixBarrelPlaneCrossing2OrderLocal::HelixBarrelPlaneCrossing2OrderLocal(), ThirdHitPredictionFromInvParabola::init(), CircleFromThreePoints::init(), ThirdHitPredictionFromCircle::invCenterOnAxis(), TkRotation< align::Scalar >::multiplyInverse(), operator*(), TkRotation< align::Scalar >::operator*(), operator+(), Basic2DVector< TmpType >::operator+=(), operator-(), Basic2DVector< TmpType >::operator-(), Basic2DVector< TmpType >::operator-=(), operator/(), Basic2DVector< TmpType >::phi(), HelixBarrelPlaneCrossingByCircle::position(), ThirdHitPredictionFromCircle::HelixRZ::rAtZ(), TrackFitter::run(), PixelFitterByHelixProjections::run(), TkRotation2D< double >::TkRotation2D(), and PV2DBase< double, PointTag, LocalTag >::y().

{ return v[1];}
template<class T>
T Basic2DVector< T >::y ( ) const [inline]

Cartesian y coordinate.

Definition at line 66 of file oldBasic2DVector.h.

{ return theY;}

Member Data Documentation

template<class T>
T Basic2DVector< T >::theX [private]

Definition at line 157 of file oldBasic2DVector.h.

Referenced by Basic2DVector< TmpType >::barePhi(), Basic2DVector< TmpType >::mag2(), Basic2DVector< TmpType >::operator*=(), Basic2DVector< TmpType >::operator+=(), Basic2DVector< TmpType >::operator-=(), Basic2DVector< TmpType >::operator/=(), Basic2DVector< TmpType >::phi(), and Basic2DVector< TmpType >::x().

template<class T>
T Basic2DVector< T >::theY [private]

Definition at line 158 of file oldBasic2DVector.h.

Referenced by Basic2DVector< TmpType >::barePhi(), Basic2DVector< TmpType >::mag2(), Basic2DVector< TmpType >::operator*=(), Basic2DVector< TmpType >::operator+=(), Basic2DVector< TmpType >::operator-=(), Basic2DVector< TmpType >::operator/=(), Basic2DVector< TmpType >::phi(), and Basic2DVector< TmpType >::y().

template<class T>
mathSSE::Vec2<T> Basic2DVector< T >::v

Definition at line 152 of file newBasic2DVector.h.

Referenced by Basic2DVector< TmpType >::cross(), Basic2DVector< TmpType >::dot(), Basic2DVector< TmpType >::mag2(), PV2DBase< double, PointTag, LocalTag >::mathVector(), Basic2DVector< TmpType >::mathVector(), operator*(), Basic2DVector< TmpType >::operator*=(), operator+(), Basic2DVector< TmpType >::operator+=(), operator-(), Basic2DVector< TmpType >::operator-(), Basic2DVector< TmpType >::operator-=(), operator/(), Basic2DVector< TmpType >::operator/=(), TkRotation2D< double >::rotate(), TkRotation2D< double >::rotateBack(), TkRotation2D< double >::TkRotation2D(), Basic2DVector< TmpType >::x(), and Basic2DVector< TmpType >::y().

Generated for CMSSW Reference Manual by doxygen 1.7.3