Merge branch 'fix/using-namespace-std' into 'master'

Fix `using namespace std` in headers

See merge request !1810

library/Demos/StdRegions/StdDemoSupport.hpp

@@ -53,7 +53,6 @@
 #include <boost/algorithm/string.hpp>
 #include <boost/program_options.hpp>
 
-using namespace std;
 using namespace Nektar;
 using namespace Nektar::LibUtilities;
 using namespace Nektar::StdRegions;
@@ -69,23 +68,23 @@ public:
             ("help,h",
              "Produce this help message and list basis and shape types.")
             ("nodal,n",
-             po::value<string>(&m_ntype),
+             po::value<std::string>(&m_ntype),
              "Optional nodal type, autofills shape and basis choices.")
             ("shape,s",
-             po::value<string>(&m_shape),
+             po::value<std::string>(&m_shape),
              "Region shape to project function on.")
             ("basis,b",
-             po::value<vector<string>>(&m_basis)->multitoken(),
+             po::value<std::vector<std::string>>(&m_basis)->multitoken(),
              "Basis type, separate by spaces for higher dimensions.")
             ("order,o",
-             po::value<vector<int>>(&m_order)->multitoken()->required(),
+             po::value<std::vector<int>>(&m_order)->multitoken()->required(),
              "Order of basis sets, separate by spaces for higher dimensions.")
             ("points,p",
-             po::value<vector<int>>(&m_points)->multitoken()->required(),
+             po::value<std::vector<int>>(&m_points)->multitoken()->required(),
              "Number of quadrature points, separate by spaces for "
              "higher dimensions.")
             ("pointstype,P",
-             po::value<vector<string>>(&m_pointstype)->multitoken(),
+             po::value<std::vector<std::string>>(&m_pointstype)->multitoken(),
              "Optional points type, separate by spaces for higher dimensions.");
         // clang-format on
     }
@@ -97,42 +96,49 @@ public:
             po::store(po::parse_command_line(argc, argv, m_desc), m_vm);
             if (m_vm.count("help"))
             {
-                cout << m_desc;
-                cout << endl << "All nodal types, -n [ --nodal ], are:" << endl;
+                std::cout << m_desc;
+                std::cout << std::endl
+                          << "All nodal types, -n [ --nodal ], are:"
+                          << std::endl;
                 for (int i = 22; i < SIZE_PointsType; ++i)
                 {
-                    cout << kPointsTypeStr[i] << endl;
+                    std::cout << kPointsTypeStr[i] << std::endl;
                 };
-                cout << endl << "All shape types, -s [ --shape ], are:" << endl;
+                std::cout << std::endl
+                          << "All shape types, -s [ --shape ], are:"
+                          << std::endl;
                 for (int i = 1; i < SIZE_ShapeType; ++i)
                 {
-                    cout << ShapeTypeMap[i] << endl;
+                    std::cout << ShapeTypeMap[i] << std::endl;
                 };
-                cout << endl << "All basis types, -b [ --basis ], are:" << endl;
+                std::cout << std::endl
+                          << "All basis types, -b [ --basis ], are:"
+                          << std::endl;
                 for (int i = 1; i < SIZE_BasisType; ++i)
                 {
-                    cout << BasisTypeMap[i] << endl;
+                    std::cout << BasisTypeMap[i] << std::endl;
                 };
-                cout << endl
-                     << "All points types, -P [ --pointstype ], are:" << endl;
+                std::cout << std::endl
+                          << "All points types, -P [ --pointstype ], are:"
+                          << std::endl;
                 for (int i = 1; i < SIZE_PointsType; ++i)
                 {
-                    cout << kPointsTypeStr[i] << endl;
+                    std::cout << kPointsTypeStr[i] << std::endl;
                 };
                 exit(0);
             }
             po::notify(m_vm);
         }
-        catch (const exception &e)
+        catch (const std::exception &e)
         {
-            cerr << "Error: " << e.what() << endl << m_desc;
+            std::cerr << "Error: " << e.what() << std::endl << m_desc;
             exit(1);
         }
     }
 
     StdExpansion *CreateStdExpansion()
     {
-        vector<PointsType> ptype;
+        std::vector<PointsType> ptype;
         if (m_vm.count("pointstype"))
         {
             for (auto &p : m_pointstype)
@@ -158,7 +164,7 @@ public:
         // Convert string input argument to nodal type
         PointsType nodaltype = eNoPointsType;
         ShapeType stype      = eNoShapeType;
-        vector<BasisType> btype(3, eNoBasisType);
+        std::vector<BasisType> btype(3, eNoBasisType);
         if (m_vm.count("nodal"))
         {
             for (int i = 22; i < SIZE_PointsType; ++i) // starts at nodal points
@@ -262,7 +268,7 @@ public:
         }
 
         // check basis selection is permitted for chosen shape
-        map<ShapeType, vector<vector<BasisType>>> allowableBasis;
+        std::map<ShapeType, std::vector<std::vector<BasisType>>> allowableBasis;
         allowableBasis[ePoint]    = {{eOrtho_A, eModified_A, eFourier,
                                       eGLL_Lagrange, eGauss_Lagrange, eLegendre,
                                       eChebyshev, eMonomial, eFourierSingleMode,
@@ -305,9 +311,9 @@ public:
                 }
                 ASSERTL0(j != basisListLength - 1,
                          ("The basis type '" +
-                          static_cast<string>(BasisTypeMap[btype[i]]) +
+                          static_cast<std::string>(BasisTypeMap[btype[i]]) +
                           "' is invalid for basis argument " +
-                          to_string(i + 1) + " for shape '" +
+                          std::to_string(i + 1) + " for shape '" +
                           ShapeTypeMap[stype] + "'."))
             }
         }
@@ -355,8 +361,8 @@ public:
             }
         }
 
-        vector<PointsKey> pkey;
-        vector<BasisKey> bkey;
+        std::vector<PointsKey> pkey;
+        std::vector<BasisKey> bkey;
         for (int i = 0; i < dimension; ++i)
         {
             pkey.emplace_back(PointsKey(m_points[i], ptype[i]));
@@ -430,12 +436,12 @@ public:
         return m_vm;
     }
 
-    std::vector<string> &GetPointsType()
+    std::vector<std::string> &GetPointsType()
     {
         return m_pointstype;
     }
 
-    std::vector<string> &GetBasisType()
+    std::vector<std::string> &GetBasisType()
     {
         return m_basis;
     }
@@ -491,10 +497,10 @@ protected:
 
     std::string m_shape;
     std::string m_ntype;
-    vector<string> m_basis{3, "NoBasisType"};
-    vector<string> m_pointstype{3, "NoPointsType"};
-    vector<int> m_order;
-    vector<int> m_points;
+    std::vector<std::string> m_basis{3, "NoBasisType"};
+    std::vector<std::string> m_pointstype{3, "NoPointsType"};
+    std::vector<int> m_order;
+    std::vector<int> m_points;
 };
 
 #endif

library/Demos/StdRegions/StdInterp.cpp

@@ -67,7 +67,7 @@ int main(int argc, char *argv[])
     // Create a new element but with the evenly-spaced points type, so that we
     // perform a PhysEvaluate at a different set of nodal points
     // (i.e. non-collocated interpolation).
-    vector<string> &ptypes = demo.GetPointsType();
+    std::vector<std::string> &ptypes = demo.GetPointsType();
     for (int i = 0; i < dimension; ++i)
     {
         ptypes[i] = "PolyEvenlySpaced";
@@ -94,9 +94,10 @@ int main(int argc, char *argv[])
 
     sol = EvalPoly(coordsF);
 
-    cout << "L infinity error : " << scientific << E->Linf(physOut, sol)
-         << endl;
-    cout << "L 2 error        : " << scientific << E->L2(physOut, sol) << endl;
+    std::cout << "L infinity error : " << std::scientific
+              << E->Linf(physOut, sol) << std::endl;
+    std::cout << "L 2 error        : " << std::scientific << E->L2(physOut, sol)
+              << std::endl;
 
     return 0;
 }

library/Demos/StdRegions/StdInterpBasis.cpp

@@ -79,8 +79,10 @@ int main(int argc, char *argv[])
         E->FillMode(k, tmp);
     }
 
-    cout << "L infinity error : " << scientific << E->Linf(phys, sol) << endl;
-    cout << "L 2 error        : " << scientific << E->L2(phys, sol) << endl;
+    std::cout << "L infinity error : " << std::scientific << E->Linf(phys, sol)
+              << std::endl;
+    std::cout << "L 2 error        : " << std::scientific << E->L2(phys, sol)
+              << std::endl;
 
     return 0;
 }

library/Demos/StdRegions/StdInterpDeriv.cpp

@@ -114,7 +114,7 @@ int main(int argc, char *argv[])
     // perform a PhysEvaluateDeriv at a different set of nodal points
     // (i.e. non-collocated interpolation), all tests use default types
     // initially
-    vector<string> &ptypes = demo.GetPointsType();
+    std::vector<std::string> &ptypes = demo.GetPointsType();
     for (int i = 0; i < dimension; ++i)
     {
         ptypes[i] = "PolyEvenlySpaced";
@@ -167,14 +167,14 @@ int main(int argc, char *argv[])
             break;
     }
 
-    cout << "\nL infinity error: " << scientific
-         << E->Linf(physOut, sol) + E->Linf(physOut0, sol0) +
-                E->Linf(physOut1, sol1) + E->Linf(physOut2, sol2)
-         << endl;
-    cout << "L 2 error         : " << scientific
-         << E->L2(physOut, sol) + E->L2(physOut0, sol0) +
-                E->L2(physOut1, sol1) + E->L2(physOut2, sol2)
-         << endl;
+    std::cout << "\nL infinity error: " << std::scientific
+              << E->Linf(physOut, sol) + E->Linf(physOut0, sol0) +
+                     E->Linf(physOut1, sol1) + E->Linf(physOut2, sol2)
+              << std::endl;
+    std::cout << "L 2 error         : " << std::scientific
+              << E->L2(physOut, sol) + E->L2(physOut0, sol0) +
+                     E->L2(physOut1, sol1) + E->L2(physOut2, sol2)
+              << std::endl;
 
     return 0;
 }

library/Demos/StdRegions/StdProject.cpp

@@ -38,8 +38,9 @@
 
 namespace po = boost::program_options;
 
-NekDouble Shape_sol(NekDouble x, NekDouble y, NekDouble z, vector<int> order,
-                    vector<BasisType> btype, ShapeType stype, bool diff);
+NekDouble Shape_sol(NekDouble x, NekDouble y, NekDouble z,
+                    std::vector<int> order, std::vector<BasisType> btype,
+                    ShapeType stype, bool diff);
 
 // Modification to deal with exact solution for diff. Return 1 if integer < 0.
 static double pow_loc(const double val, const int i)
@@ -161,10 +162,10 @@ int main(int argc, char *argv[])
     }
 
     // Calculate L_inf & L_2 error
-    cout << "L infinity error: \t" << E->Linf(phys, sol) << endl;
+    std::cout << "L infinity error: \t" << E->Linf(phys, sol) << std::endl;
     if (stype != ePoint)
     {
-        cout << "L 2 error: \t \t \t" << E->L2(phys, sol) << endl;
+        std::cout << "L 2 error: \t \t \t" << E->L2(phys, sol) << std::endl;
     }
 
     if (!vm.count("diff") && stype != ePoint)
@@ -178,12 +179,12 @@ int main(int argc, char *argv[])
 
         NekDouble nsol = E->PhysEvaluate(t, phys);
 
-        cout << "Error at x = (";
+        std::cout << "Error at x = (";
         for (int i = 0; i < dimension; ++i)
         {
-            cout << t[i] << ", ";
+            std::cout << t[i] << ", ";
         }
-        cout << "\b\b): " << nsol - sol[0] << endl;
+        std::cout << "\b\b): " << nsol - sol[0] << std::endl;
     }
 
     // Calculate integral of known function to test different quadrature
@@ -231,54 +232,63 @@ int main(int argc, char *argv[])
     return 0;
 }
 
-NekDouble Shape_sol(NekDouble x, NekDouble y, NekDouble z, vector<int> order,
-                    vector<BasisType> btype, ShapeType stype, bool diff)
+NekDouble Shape_sol(NekDouble x, NekDouble y, NekDouble z,
+                    std::vector<int> order, std::vector<BasisType> btype,
+                    ShapeType stype, bool diff)
 {
-    map<ShapeType, function<int(int, const vector<int> &)>> shapeConstraint2;
-    shapeConstraint2[ePoint]    = [](int, const vector<int> &) { return 1; };
-    shapeConstraint2[eSegment]  = [](int, const vector<int> &) { return 1; };
-    shapeConstraint2[eTriangle] = [](int k, const vector<int> &order) {
+    std::map<ShapeType, std::function<int(int, const std::vector<int> &)>>
+        shapeConstraint2;
+    shapeConstraint2[ePoint] = [](int, const std::vector<int> &) { return 1; };
+    shapeConstraint2[eSegment] = [](int, const std::vector<int> &) {
+        return 1;
+    };
+    shapeConstraint2[eTriangle] = [](int k, const std::vector<int> &order) {
         return order[1] - k;
     };
-    shapeConstraint2[eQuadrilateral] = [](int, const vector<int> &order) {
+    shapeConstraint2[eQuadrilateral] = [](int, const std::vector<int> &order) {
         return order[1];
     };
-    shapeConstraint2[eTetrahedron] = [](int k, const vector<int> &order) {
+    shapeConstraint2[eTetrahedron] = [](int k, const std::vector<int> &order) {
         return order[1] - k;
     };
-    shapeConstraint2[ePyramid] = [](int k, const vector<int> &order) {
+    shapeConstraint2[ePyramid] = [](int k, const std::vector<int> &order) {
         return order[1] - k;
     };
-    shapeConstraint2[ePrism] = [](int, const vector<int> &order) {
+    shapeConstraint2[ePrism] = [](int, const std::vector<int> &order) {
         return order[1];
     };
-    shapeConstraint2[eHexahedron] = [](int, const vector<int> &order) {
+    shapeConstraint2[eHexahedron] = [](int, const std::vector<int> &order) {
         return order[1];
     };
 
-    map<ShapeType, function<int(int, int, const vector<int> &order)>>
+    std::map<ShapeType,
+             std::function<int(int, int, const std::vector<int> &order)>>
         shapeConstraint3;
-    shapeConstraint3[ePoint] = [](int, int, const vector<int> &) { return 1; };
-    shapeConstraint3[eSegment] = [](int, int, const vector<int> &) {
+    shapeConstraint3[ePoint] = [](int, int, const std::vector<int> &) {
+        return 1;
+    };
+    shapeConstraint3[eSegment] = [](int, int, const std::vector<int> &) {
         return 1;
     };
-    shapeConstraint3[eTriangle] = [](int, int, const vector<int> &) {
+    shapeConstraint3[eTriangle] = [](int, int, const std::vector<int> &) {
         return 1;
     };
-    shapeConstraint3[eQuadrilateral] = [](int, int, const vector<int> &) {
+    shapeConstraint3[eQuadrilateral] = [](int, int, const std::vector<int> &) {
         return 1;
     };
-    shapeConstraint3[eTetrahedron] =
-        [](int k, int l, const vector<int> &order) { return order[2] - k - l; };
-    shapeConstraint3[ePyramid] = [](int k, int l, const vector<int> &order) {
+    shapeConstraint3[eTetrahedron] = [](int k, int l,
+                                        const std::vector<int> &order) {
         return order[2] - k - l;
     };
-    shapeConstraint3[ePrism] = [](int k, int, const vector<int> &order) {
-        return order[2] - k;
+    shapeConstraint3[ePyramid] = [](int k, int l,
+                                    const std::vector<int> &order) {
+        return order[2] - k - l;
     };
-    shapeConstraint3[eHexahedron] = [](int, int, const vector<int> &order) {
-        return order[2];
+    shapeConstraint3[ePrism] = [](int k, int, const std::vector<int> &order) {
+        return order[2] - k;
     };
+    shapeConstraint3[eHexahedron] =
+        [](int, int, const std::vector<int> &order) { return order[2]; };
 
     NekDouble sol = 0.0;
     if (!diff)

library/LibUtilities/BasicUtils/Smath.hpp

@@ -41,7 +41,7 @@
 #include <algorithm>
 #include <cstdlib>
 #include <math.h>
-using namespace std;
+
 using namespace Nektar;
 
 namespace Smath

library/LibUtilities/TimeIntegration/DIRKTimeIntegrationSchemes.h

@@ -42,7 +42,6 @@
 #define NEKTAR_LIB_UTILITIES_TIME_INTEGRATION_DIRK_TIME_INTEGRATION_SCHEME
 
 #define LUE LIB_UTILITIES_EXPORT
-using namespace std;
 
 #include <LibUtilities/TimeIntegration/TimeIntegrationSchemeGLM.h>