revert back to using std:: as it seems to cause issues with gcc build…

…s. Works with Vc as long as Vc's headers are included first...

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

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

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

@@ -109,26 +109,13 @@ public :
    Scalar Z()     const { return fZ;}
    Scalar Mag2()  const { return fX*fX + fY*fY + fZ*fZ;}
    Scalar Perp2() const { return fX*fX + fY*fY ;}
-   Scalar Rho() const
-   {
-      using namespace std;
-      return sqrt(Perp2());
-   }
-   Scalar R() const
-   {
-      using namespace std;
-      return sqrt(Mag2());
-   }
+   Scalar Rho() const { return std::sqrt(Perp2()); }
+   Scalar R() const { return std::sqrt(Mag2()); }
    Scalar Theta() const
    {
-      using namespace std;
-      return (fX == Scalar(0) && fY == Scalar(0) && fZ == Scalar(0)) ? Scalar(0) : atan2(Rho(), Z());
-   }
-   Scalar Phi() const
-   {
-      using namespace std;
-      return (fX == Scalar(0) && fY == Scalar(0)) ? Scalar(0) : atan2(fY, fX);
+      return (fX == Scalar(0) && fY == Scalar(0) && fZ == Scalar(0)) ? Scalar(0) : std::atan2(Rho(), Z());
    }
+   Scalar Phi() const { return (fX == Scalar(0) && fY == Scalar(0)) ? Scalar(0) : std::atan2(fY, fX); }
 
    // pseudorapidity
    Scalar Eta() const {
@@ -208,12 +195,11 @@ public :
    template <class T2>
    explicit Cartesian3D( const Polar3D<T2> & v ) : fZ (v.Z())
    {
-      using namespace std;
       const T rho = v.Rho();
       // re-using this instead of calling v.X() and v.Y()
       // is the speed improvement
-      fX = rho * cos(v.Phi());
-      fY = rho * sin(v.Phi());
+      fX = rho * std::cos(v.Phi());
+      fY = rho * std::sin(v.Phi());
    }
    // Technical note:  This works even though only Polar3Dfwd.h is
    // included (and in fact, including Polar3D.h would cause circularity
@@ -223,10 +209,9 @@ public :
    template <class T2>
    Cartesian3D & operator = (const Polar3D<T2> & v)
    {
-      using namespace std;
       const T rho = v.Rho();
-      fX          = rho * cos(v.Phi());
-      fY          = rho * sin(v.Phi());
+      fX          = rho * std::cos(v.Phi());
+      fY          = rho * std::sin(v.Phi());
       fZ = v.Z();
       return *this;
    }

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

@@ -109,9 +109,7 @@ public :
    inline static Scalar pi() { return Scalar(M_PI); }
    inline void          Restrict()
    {
-      using namespace std;
-      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
-      return;
+      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - std::floor(fPhi / (2 * pi()) + .5) * 2 * pi();
    }
 public:
 
@@ -121,29 +119,13 @@ public :
    Scalar Z()     const { return fZ;   }
    Scalar Phi()   const { return fPhi; }
 
-   Scalar X() const
-   {
-      using namespace std;
-      return fRho * cos(fPhi);
-   }
-   Scalar Y() const
-   {
-      using namespace std;
-      return fRho * sin(fPhi);
-   }
+   Scalar X() const { return fRho * std::cos(fPhi); }
+   Scalar Y() const { return fRho * std::sin(fPhi); }
 
    Scalar Mag2()  const { return fRho*fRho + fZ*fZ;   }
-   Scalar R() const
-   {
-      using namespace std;
-      return sqrt(Mag2());
-   }
+   Scalar R() const { return std::sqrt(Mag2()); }
    Scalar Perp2() const { return fRho*fRho;           }
-   Scalar Theta() const
-   {
-      using namespace std;
-      return (fRho == Scalar(0) && fZ == Scalar(0)) ? Scalar(0) : atan2(fRho, fZ);
-   }
+   Scalar Theta() const { return (fRho == Scalar(0) && fZ == Scalar(0)) ? Scalar(0) : std::atan2(fRho, fZ); }
 
    // pseudorapidity - use same implementation as in Cartesian3D
    Scalar Eta() const {

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

@@ -70,7 +70,6 @@ public :
   explicit CylindricalEta3D( const CoordSystem & v ) :
      fRho(v.Rho() ),  fEta(v.Eta() ),  fPhi(v.Phi() )
   {
-     using namespace std;
      static Scalar bigEta = Scalar(-0.3) * log(std::numeric_limits<Scalar>::epsilon());
      if (fabs(fEta) > bigEta) {
         // This gives a small absolute adjustment in rho,
@@ -126,8 +125,7 @@ public :
 private:
    inline static Scalar pi() { return M_PI; }
    inline void Restrict() {
-      using namespace std;
-      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
+      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - std::floor(fPhi / (2 * pi()) + .5) * 2 * pi();
       return;
    }
 public:
@@ -137,34 +135,24 @@ public :
    T Rho()   const { return fRho; }
    T Eta()   const { return fEta; }
    T Phi()   const { return fPhi; }
-   T X() const
-   {
-      using namespace std;
-      return fRho * cos(fPhi);
-   }
-   T Y() const
-   {
-      using namespace std;
-      return fRho * sin(fPhi);
-   }
+   T X() const { return fRho * std::cos(fPhi); }
+   T Y() const { return fRho * std::sin(fPhi); }
    T Z() const
    {
-      using namespace std;
-      return fRho > 0 ? fRho * sinh(fEta) : fEta == 0 ? 0 : fEta > 0 ? fEta - etaMax<T>() : fEta + etaMax<T>();
+      return fRho > 0 ? fRho * std::sinh(fEta) : fEta == 0 ? 0 : fEta > 0 ? fEta - etaMax<T>() : fEta + etaMax<T>();
    }
    T R() const
    {
-      using namespace std;
-      return fRho > 0 ? fRho * cosh(fEta)
+      return fRho > 0 ? fRho * std::cosh(fEta)
                       : fEta > etaMax<T>() ? fEta - etaMax<T>() : fEta < -etaMax<T>() ? -fEta - etaMax<T>() : 0;
    }
-   T Mag2()  const { return R()*R();              }
-   T Perp2() const { return fRho*fRho;            }
-   T Theta() const
+   T Mag2() const
    {
-      using namespace std;
-      return fRho > 0 ? 2 * atan(exp(-fEta)) : (fEta >= 0 ? 0 : pi());
+      const Scalar r = R();
+      return r * r;
    }
+   T Perp2() const { return fRho*fRho;            }
+   T Theta() const { return fRho > 0 ? 2 * std::atan(exp(-fEta)) : (fEta >= 0 ? 0 : pi()); }
 
    // setters (only for data members)
 

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

@@ -488,10 +488,9 @@ namespace ROOT {
           // TODO - It would be good to check that E > Pz and use the Throw()
           //        mechanism or at least load a NAN if not.
           //        We should then move the code to a .cpp file.
-          using namespace std;
-          Scalar ee = E();
-          Scalar ppz = Pz();
-          return Scalar(0.5) * log((ee + ppz) / (ee - ppz));
+          const Scalar ee  = E();
+          const Scalar ppz = Pz();
+          return Scalar(0.5) * std::log((ee + ppz) / (ee - ppz));
        }
 
        /**
@@ -500,10 +499,9 @@ namespace ROOT {
        Scalar ColinearRapidity() const {
           // TODO - It would be good to check that E > P and use the Throw()
           //        mechanism or at least load a NAN if not.
-          using namespace std;
-          Scalar ee = E();
-          Scalar pp = P();
-          return Scalar(0.5) * log((ee + pp) / (ee - pp));
+          const Scalar ee = E();
+          const Scalar pp = P();
+          return Scalar(0.5) * std::log((ee + pp) / (ee - pp));
        }
 
        /**
@@ -599,9 +597,8 @@ namespace ROOT {
            Return Gamma scalar value
        */
        Scalar Gamma() const {
-          using namespace std;
-          Scalar v2 = P2();
-          Scalar t2 = E()*E();
+          const Scalar v2 = P2();
+          const Scalar t2 = std::pow(E(), 2);
           if (E() == 0) {
              if ( P2() == 0) {
                 return 1;
@@ -617,7 +614,7 @@ namespace ROOT {
           else if ( t2 == v2 ) {
              GenVector::Throw ("LorentzVector::Gamma() - gamma computed for a lightlike LorentzVector. Infinite result");
           }
-          return Scalar(1) / sqrt(Scalar(1) - v2 / t2);
+          return Scalar(1) / std::sqrt(Scalar(1) - v2 / t2);
        } /* gamma */
 
 

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

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

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

@@ -110,32 +110,12 @@ public :
    Scalar R()     const { return fR;}
    Scalar Phi()   const { return fPhi; }
    Scalar Theta() const { return fTheta; }
-   Scalar Rho() const
-   {
-      using namespace std;
-      return fR * sin(fTheta);
-   }
-   Scalar X() const
-   {
-      using namespace std;
-      return Rho() * cos(fPhi);
-   }
-   Scalar Y() const
-   {
-      using namespace std;
-      return Rho() * sin(fPhi);
-   }
-   Scalar Z() const
-   {
-      using namespace std;
-      return fR * cos(fTheta);
-   }
+   Scalar Rho() const { return fR * std::sin(fTheta); }
+   Scalar X() const { return Rho() * std::cos(fPhi); }
+   Scalar Y() const { return Rho() * std::sin(fPhi); }
+   Scalar Z() const { return fR * std::cos(fTheta); }
    Scalar Mag2()  const { return fR*fR;}
-   Scalar Perp2() const
-   {
-      const Scalar r = Rho();
-      return r * r;
-   }
+   Scalar Perp2() const { return std::pow(Rho(), 2); }
 
    // pseudorapidity
    Scalar Eta() const
@@ -177,9 +157,7 @@ public :
 private:
    inline static Scalar pi()  { return M_PI; }
    inline void Restrict() {
-      using namespace std;
-      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - floor(fPhi / (2 * pi()) + .5) * 2 * pi();
-      return;
+      if (fPhi <= -pi() || fPhi > pi()) fPhi = fPhi - std::floor(fPhi / (2 * pi()) + .5) * 2 * pi();
    }
 
 public:
@@ -229,8 +207,8 @@ public :
 
    // The following make this coordinate system look enough like a CLHEP
    // vector that an assignment member template can work with either
-   T x() const { return X();}
-   T y() const { return Y();}
+   T x() const { return X(); }
+   T y() const { return Y(); }
    T z() const { return Z(); }
 
    // ============= Specializations for improved speed ==================