Extend the 'using namespace std' trick to a few more classes

math/genvector/inc/Math/GenVector/Cartesian2D.h

@@ -89,8 +89,9 @@ public :
    Scalar X()     const { return fX;}
    Scalar Y()     const { return fY;}
    Scalar Mag2()  const { return fX*fX + fY*fY; }
-   Scalar R()     const { return std::sqrt( Mag2());}
-   Scalar Phi()   const { return (fX==0 && fY==0) ? 0.0 : atan2(fY,fX);}
+   Scalar R()     const { using namespace std; return sqrt( Mag2()); }
+   Scalar Phi()   const { using namespace std;
+                          return (fX==Scalar(0) && fY==Scalar(0)) ? Scalar(0) : atan2(fY,fX);}
 
    /**
        set the x coordinate value keeping y constant
@@ -124,8 +125,9 @@ public :
        rotate by an angle
     */
    void Rotate(Scalar angle) {
-      Scalar s = std::sin(angle);
-      Scalar c = std::cos(angle);
+      using namespace std;
+      const Scalar s = sin(angle);
+      const Scalar c = cos(angle);
       SetCoordinates( c*fX - s*fY, s*fX + c * fY );
    }
 
@@ -161,10 +163,11 @@ public :
    template <class T2>
    explicit Cartesian2D( const Polar2D<T2> & v )
    {
-      Scalar r = v.R();    // re-using this instead of calling v.X() and v.Y()
+      using namespace std;
+      const Scalar r = v.R();    // re-using this instead of calling v.X() and v.Y()
       // is the speed improvement
-      fX = r * std::cos(v.Phi());
-      fY = r * std::sin(v.Phi());
+      fX = r * cos(v.Phi());
+      fY = r * sin(v.Phi());
    }
    // Technical note:  This works even though only Polar2Dfwd.h is
    // included (and in fact, including Polar2D.h would cause circularity
@@ -174,9 +177,10 @@ public :
    template <class T2>
    Cartesian2D & operator = (const Polar2D<T2> & v)
    {
-      Scalar r = v.R();
-      fX = r * std::cos(v.Phi());
-      fY = r * std::sin(v.Phi());
+      using namespace std;
+      const Scalar r = v.R();
+      fX = r * cos(v.Phi());
+      fY = r * sin(v.Phi());
       return *this;
    }
 

math/genvector/inc/Math/GenVector/Cartesian3D.h

@@ -120,7 +120,7 @@ public :
 
    // pseudorapidity
    Scalar Eta() const {
-      return Impl::Eta_FromRhoZ ( Rho(),fZ);
+      return Impl::Eta_FromRhoZ( Rho(), fZ );
    }
 
    /**

math/genvector/inc/Math/GenVector/Cylindrical3D.h

@@ -106,10 +106,12 @@ public :
    {rho=fRho; zz=fZ; phi=fPhi;}
 
 private:
-   inline static Scalar pi() { return M_PI; }
-   inline void Restrict() {
+   inline static Scalar pi() { return Scalar(M_PI); }
+   inline void Restrict()
+   {
+      using namespace std;
       if ( fPhi <= -pi() || fPhi > pi() )
-         fPhi = fPhi - std::floor( fPhi/(2*pi()) +.5 ) * 2*pi();
+         fPhi = fPhi - floor( fPhi/(2*pi()) +.5 ) * 2*pi();
       return;
    }
 public:
@@ -120,13 +122,16 @@ public :
    Scalar Z()     const { return fZ;   }
    Scalar Phi()   const { return fPhi; }
 
-   Scalar X()     const { return fRho*std::cos(fPhi); }
-   Scalar Y()     const { return fRho*std::sin(fPhi); }
+   Scalar X()     const { using namespace std; return fRho*cos(fPhi); }
+   Scalar Y()     const { using namespace std; return fRho*sin(fPhi); }
 
    Scalar Mag2()  const { return fRho*fRho + fZ*fZ;   }
-   Scalar R()     const { return std::sqrt( Mag2());  }
+   Scalar R()     const { using namespace std; return sqrt( Mag2());  }
    Scalar Perp2() const { return fRho*fRho;           }
-   Scalar Theta() const { return (fRho==0 && fZ==0 ) ? 0 : atan2(fRho,fZ); }
+   Scalar Theta() const {
+     using namespace std;
+     return (fRho==Scalar(0) && fZ==Scalar(0) ) ? Scalar(0) : atan2(fRho,fZ);
+   }
 
    // pseudorapidity - use same implementation as in Cartesian3D
    Scalar Eta() const {

math/genvector/inc/Math/GenVector/Polar2D.h

@@ -97,8 +97,8 @@ public :
 
    Scalar R()     const { return fR;}
    Scalar Phi()   const { return fPhi; }
-   Scalar X()     const { return fR*std::cos(fPhi);}
-   Scalar Y()     const { return fR*std::sin(fPhi);}
+   Scalar X()     const { using namespace std; return fR*cos(fPhi);}
+   Scalar Y()     const { using namespace std; return fR*sin(fPhi);}
    Scalar Mag2()  const { return fR*fR;}
 
 
@@ -134,8 +134,9 @@ public :
       restrict abgle hi to be between -PI and PI
     */
    inline void Restrict() {
+      using namespace std;
       if ( fPhi <= -pi() || fPhi > pi() )
-         fPhi = fPhi - std::floor( fPhi/(2*pi()) +.5 ) * 2*pi();
+         fPhi = fPhi - floor( fPhi/(2*pi()) +.5 ) * 2*pi();
       return;
    }
 

math/genvector/inc/Math/GenVector/PtEtaPhiE4D.h

@@ -137,26 +137,28 @@ public :
 
    // other coordinate representation
 
-   Scalar Px() const { return fPt*cos(fPhi);}
+   Scalar Px() const { using namespace std; return cos(fPhi);}
    Scalar X () const { return Px();         }
-   Scalar Py() const { return fPt*sin(fPhi);}
+   Scalar Py() const { using namespace std; return sin(fPhi);}
    Scalar Y () const { return Py();         }
    Scalar Pz() const {
-      return fPt >   0 ? fPt*std::sinh(fEta)     :
-         fEta == 0 ? 0                       :
-         fEta >  0 ? fEta - etaMax<Scalar>() :
-         fEta + etaMax<Scalar>() ;
+      using namespace std; 
+      return ( fPt >   0 ? fPt*sinh(fEta)          :
+               fEta == 0 ? 0                       :
+               fEta >  0 ? fEta - etaMax<Scalar>() :
+               fEta + etaMax<Scalar>() );
    }
    Scalar Z () const { return Pz(); }
 
    /**
        magnitude of momentum
    */
    Scalar P() const {
-      return  fPt  > 0                 ?  fPt*std::cosh(fEta)       :
-         fEta >  etaMax<Scalar>() ?  fEta - etaMax<Scalar>()   :
-         fEta < -etaMax<Scalar>() ? -fEta - etaMax<Scalar>()   :
-         0                         ;
+      using namespace std; 
+      return ( fPt  > 0                 ?  fPt*cosh(fEta)           :
+               fEta >  etaMax<Scalar>() ?  fEta - etaMax<Scalar>()  :
+               fEta < -etaMax<Scalar>() ? -fEta - etaMax<Scalar>()  :
+               0                                                   );
    }
    Scalar R() const { return P(); }
 
@@ -175,13 +177,14 @@ public :
       invariant mass
    */
    Scalar M() const    {
+      using namespace std; 
       Scalar mm = M2();
       if (mm >= 0) {
-         return std::sqrt(mm);
+         return sqrt(mm);
       } else {
          GenVector::Throw ("PtEtaPhiE4D::M() - Tachyonic:\n"
                            "    Pt and Eta give P such that P^2 > E^2, so the mass would be imaginary");
-         return -std::sqrt(-mm);
+         return -sqrt(-mm);
       }
    }
    Scalar Mag() const    { return M(); }
@@ -201,13 +204,14 @@ public :
       transverse mass
    */
    Scalar Mt() const {
+      using namespace std; 
       Scalar mm = Mt2();
       if (mm >= 0) {
-         return std::sqrt(mm);
+         return sqrt(mm);
       } else {
          GenVector::Throw ("PtEtaPhiE4D::Mt() - Tachyonic:\n"
                            "    Pt and Eta give Pz such that Pz^2 > E^2, so the mass would be imaginary");
-         return -std::sqrt(-mm);
+         return -sqrt(-mm);
       }
    }
 
@@ -218,7 +222,8 @@ public :
       transverse energy
    */
    Scalar Et() const {
-      return fE / std::cosh(fEta); // faster using eta
+      using namespace std; 
+      return fE / cosh(fEta); // faster using eta
    }
 
    /**
@@ -230,8 +235,9 @@ public :
 private:
    inline static Scalar pi() { return M_PI; }
    inline void Restrict() {
+      using namespace std; 
       if ( fPhi <= -pi() || fPhi > pi() )
-         fPhi = fPhi - std::floor( fPhi/(2*pi()) +.5 ) * 2*pi();
+         fPhi = fPhi - floor( fPhi/(2*pi()) +.5 ) * 2*pi();
       return;
    }
 public:
@@ -240,9 +246,9 @@ public :
       polar angle
    */
    Scalar Theta() const {
-      if (fPt  >  0) return 2* std::atan( exp( - fEta ) );
-      if (fEta >= 0) return 0;
-      return pi();
+      using namespace std; 
+      return ( fPt  >  0 ? Scalar(2) * atan( exp( - fEta ) ) :
+               fEta >= 0 ? Scalar(0) : pi() );
    }
 
    // --------- Set Coordinates of this system  ---------------

math/genvector/inc/Math/GenVector/PxPyPzE4D.h

@@ -148,13 +148,14 @@ public :
       invariant mass
    */
    Scalar M() const    {
+      using namespace std;
       Scalar mm = M2();
       if (mm >= 0) {
-         return std::sqrt(mm);
+         return sqrt(mm);
       } else {
          GenVector::Throw ("PxPyPzE4D::M() - Tachyonic:\n"
                    "    P^2 > E^2 so the mass would be imaginary");
-         return -std::sqrt(-mm);
+         return -sqrt(-mm);
       }
    }
    Scalar Mag() const    { return M(); }
@@ -168,7 +169,7 @@ public :
    /**
       Transverse spatial component (P_perp or rho)
    */
-   Scalar Pt()   const { return std::sqrt(Perp2());}
+   Scalar Pt()   const { using namespace std; return std::sqrt(Perp2());}
    Scalar Perp() const { return Pt();}
    Scalar Rho()  const { return Pt();}
 
@@ -181,13 +182,14 @@ public :
       transverse mass
    */
    Scalar Mt() const {
+      using namespace std;
       Scalar mm = Mt2();
-      if (mm >= 0) {
-         return std::sqrt(mm);
+      if ( mm >= 0 ) {
+         return sqrt(mm);
       } else {
          GenVector::Throw ("PxPyPzE4D::Mt() - Tachyonic:\n"
                            "    Pz^2 > E^2 so the transverse mass would be imaginary");
-         return -std::sqrt(-mm);
+         return -sqrt(-mm);
       }
    }
 
@@ -204,22 +206,25 @@ public :
       transverse energy
    */
    Scalar Et() const {
+      using namespace std;
       Scalar etet = Et2();
-      return fT < 0.0 ? -std::sqrt(etet) : std::sqrt(etet);
+      return fT < 0.0 ? -sqrt(etet) : sqrt(etet);
    }
 
    /**
       azimuthal angle
    */
    Scalar Phi() const  {
-      return (fX == 0.0 && fY == 0.0) ? 0 : std::atan2(fY,fX);
+      using namespace std;
+      return ( fX == Scalar(0) && fY == Scalar(0) ) ? Scalar(0) : atan2(fY,fX);
    }
 
    /**
       polar angle
    */
    Scalar Theta() const {
-      return (fX == 0.0 && fY == 0.0 && fZ == 0.0) ? 0 : std::atan2(Pt(),fZ);
+      using namespace std;
+      return (fX == Scalar(0) && fY == Scalar(0) && fZ == Scalar(0) ) ? Scalar(0) : atan2(Pt(),fZ);
    }
 
    /**

math/genvector/inc/Math/GenVector/eta.h

@@ -46,15 +46,16 @@ namespace ROOT {
      */
         template<typename Scalar>
         inline Scalar Eta_FromRhoZ(Scalar rho, Scalar z) {
+           using namespace std;
            if (rho > 0) {
 
               // value to control Taylor expansion of sqrt
               static const Scalar big_z_scaled =
-                 std::pow(std::numeric_limits<Scalar>::epsilon(),static_cast<Scalar>(-.25));
+                 pow(std::numeric_limits<Scalar>::epsilon(),static_cast<Scalar>(-.25));
 
               Scalar z_scaled = z/rho;
-              if (std::fabs(z_scaled) < big_z_scaled) {
-                 return std::log(z_scaled+std::sqrt(z_scaled*z_scaled+1.0));
+              if (fabs(z_scaled) < big_z_scaled) {
+                 return log(z_scaled+std::sqrt(z_scaled*z_scaled+1.0));
               } else {
                  // apply correction using first order Taylor expansion of sqrt
                  return  z>0 ? std::log(2.0*z_scaled + 0.5/z_scaled) : -std::log(-2.0*z_scaled);