]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Replace typedef by using in examples
authorDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Wed, 27 Jun 2018 13:10:26 +0000 (15:10 +0200)
committerDaniel Arndt <daniel.arndt@iwr.uni-heidelberg.de>
Wed, 27 Jun 2018 13:10:26 +0000 (15:10 +0200)
17 files changed:
examples/step-12/step-12.cc
examples/step-13/step-13.cc
examples/step-14/step-14.cc
examples/step-16/step-16.cc
examples/step-22/doc/intro.dox
examples/step-22/step-22.cc
examples/step-3/doc/intro.dox
examples/step-32/step-32.cc
examples/step-33/doc/intro.dox
examples/step-35/step-35.cc
examples/step-37/step-37.cc
examples/step-39/step-39.cc
examples/step-40/doc/intro.dox
examples/step-50/step-50.cc
examples/step-55/step-55.cc
examples/step-56/step-56.cc
examples/step-59/step-59.cc

index 3f4b85c354078da4f4c62fa376fe188b0abca29b..81f58761d5285f614d43e942052e0ceca0722d0a 100644 (file)
@@ -189,10 +189,10 @@ namespace Step12
     // all cells and much of the setup of operations will be done outside this
     // class, so all we have to provide are these three operations. They will
     // then work on intermediate objects for which first, we here define
-    // typedefs to the info objects handed to the local integration functions
+    // alias to the info objects handed to the local integration functions
     // in order to make our life easier below.
-    typedef MeshWorker::DoFInfo<dim>         DoFInfo;
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using DoFInfo  = MeshWorker::DoFInfo<dim>;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     // The following three functions are then the ones that get called inside
     // the generic loop over all cells and faces. They are the ones doing the
index c8690cd25c9206c0cacd95ae110b0e63ff520d34..d65b252ecef65896943b279b303478552361c0c4 100644 (file)
@@ -1373,7 +1373,7 @@ namespace Step13
 
         // Now solve the problem on the present grid, and run the evaluators
         // on it. The long type name of iterators into the list is a little
-        // annoying, but could be shortened by a typedef, if so desired.
+        // annoying, but could be shortened by an alias, if so desired.
         solver.solve_problem();
 
         for (typename std::list<
index 0a99b1f99200dbbcff5c180ba8e1e7da4b91a682..8d052eb7e347098e3b623c866cc10a22c0a4ec77 100644 (file)
@@ -1240,8 +1240,8 @@ namespace Step14
     {
       // We need a class to denote the boundary values of the problem. In this
       // case, this is simple: it's the zero function, so don't even declare a
-      // class, just a typedef:
-      typedef Functions::ZeroFunction<dim> BoundaryValues;
+      // class, just an alias:
+      using BoundaryValues = Functions::ZeroFunction<dim>;
 
       // Second, a class that denotes the right hand side. Since they are
       // constant, just subclass the corresponding class of the library and be
@@ -1760,8 +1760,8 @@ namespace Step14
       // Then declare abbreviations for active cell iterators, to avoid that
       // we have to write this lengthy name over and over again:
 
-      typedef
-        typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
+      using active_cell_iterator =
+        typename DoFHandler<dim>::active_cell_iterator;
 
       // Next, declare a data type that we will us to store the contribution
       // of faces to the error estimator. The idea is that we can compute the
@@ -1774,8 +1774,8 @@ namespace Step14
       // cells a second time and grabbing the values from the map.
       //
       // The data type of this map is declared here:
-      typedef typename std::map<typename DoFHandler<dim>::face_iterator, double>
-        FaceIntegrals;
+      using FaceIntegrals =
+        typename std::map<typename DoFHandler<dim>::face_iterator, double>;
 
       // In the computation of the error estimates on cells and faces, we need
       // a number of helper objects, such as <code>FEValues</code> and
@@ -2660,8 +2660,8 @@ namespace Step14
   public:
     // First, we declare two abbreviations for simple use of the respective
     // data types:
-    typedef Evaluation::EvaluationBase<dim> Evaluator;
-    typedef std::list<Evaluator *>          EvaluatorList;
+    using Evaluator     = Evaluation::EvaluationBase<dim>;
+    using EvaluatorList = std::list<Evaluator *>;
 
 
     // Then we have the structure which declares all the parameters that may
index 0b1394dd84c828c80480e99830a70f3f9e3c03b4..12a7064fd3f1a1dd780cd1dcee4c74eb582f6c82 100644 (file)
@@ -504,8 +504,8 @@ namespace Step16
     // (such as CG or GMRES). The mg::SmootherRelaxation and
     // MGSmootherPrecondition classes provide support for these two kinds of
     // smoothers. Here, we opt for the application of a single SOR
-    // iteration. To this end, we define an appropriate <code>typedef</code>
-    // and then setup a smoother object.
+    // iteration. To this end, we define an appropriate alias and then setup a
+    // smoother object.
     //
     // The last step is to initialize the smoother object with our level
     // matrices and to set some smoothing parameters.  The
@@ -523,7 +523,7 @@ namespace Step16
     // iteration (which requires a symmetric preconditioner) below, we need to
     // let the multilevel preconditioner make sure that we get a symmetric
     // operator even for nonsymmetric smoothers:
-    typedef PreconditionSOR<SparseMatrix<double>>    Smoother;
+    using Smoother = PreconditionSOR<SparseMatrix<double>>;
     mg::SmootherRelaxation<Smoother, Vector<double>> mg_smoother;
     mg_smoother.initialize(mg_matrices);
     mg_smoother.set_steps(2);
index ead7896cc7512d0b784cc87cfa7903a62b064516..5f05760c9a54b51466f206eadccca1c2dedd22d2 100644 (file)
@@ -554,13 +554,13 @@ struct InnerPreconditioner;
 template <>
 struct InnerPreconditioner<2>
 {
-    typedef SparseDirectUMFPACK type;
+  using type = SparseDirectUMFPACK;
 };
 
 template <>
 struct InnerPreconditioner<3>
 {
-    typedef SparseILU<double> type;
+  using type = SparseILU<double>;
 };
 @endcode
 
index dd023a8c7381c76b5d27fcfad1e6931f6c246dec..caa29fab3f77e2a502a6d51b52c9373a9dd7e21c 100644 (file)
@@ -79,7 +79,7 @@ namespace Step22
   // distinguish between them by the use of the spatial dimension as a
   // template parameter. See step-4 for details on templates. We are not going
   // to create any preconditioner object here, all we do is to create class
-  // that holds a local typedef determining the preconditioner class so we can
+  // that holds a local alias determining the preconditioner class so we can
   // write our program in a dimension-independent way.
   template <int dim>
   struct InnerPreconditioner;
@@ -88,14 +88,14 @@ namespace Step22
   template <>
   struct InnerPreconditioner<2>
   {
-    typedef SparseDirectUMFPACK type;
+    using type = SparseDirectUMFPACK;
   };
 
   // And the ILU preconditioning in 3D, called by SparseILU:
   template <>
   struct InnerPreconditioner<3>
   {
-    typedef SparseILU<double> type;
+    using type = SparseILU<double>;
   };
 
 
@@ -757,7 +757,7 @@ namespace Step22
     // preconditioner for the velocity-velocity matrix, i.e.,
     // <code>block(0,0)</code> in the system matrix. As mentioned above, this
     // depends on the spatial dimension. Since the two classes described by
-    // the <code>InnerPreconditioner::type</code> typedef have the same
+    // the <code>InnerPreconditioner::type</code> alias have the same
     // interface, we do not have to do anything different whether we want to
     // use a sparse direct solver or an ILU:
     std::cout << "   Computing preconditioner..." << std::endl << std::flush;
index f2b688a2456556f3e47142704841c17c3b62ec2a..3ab7f6e42e9d1cdd6cc09791875c48f20c1501bd 100644 (file)
@@ -335,20 +335,19 @@ following tutorial programs.
 
 <h3> A note on types </h3>
 
-deal.II defines a number of integral %types via <code>typedef</code>s in
-namespace types. In particular, in this program you will see
-types::global_dof_index in a couple of places: an integer type that is used to
-denote the <i>global</i> index of a degree of freedom, i.e., the index of a
-particular degree of freedom within the DoFHandler object that is defined on
-top of a triangulation (as opposed to the index of a particular degree of
-freedom within a particular cell). For the current program
-(as well as almost all of the tutorial programs), you will have a few thousand
-to maybe a few million unknowns globally (and, for $Q_1$ elements, you will
-have 4 <i>locally on each cell</i> in 2d and 8 in 3d). Consequently, a data
-type that allows to store sufficiently large numbers for global DoF indices is
-<code>unsigned int</code> given that it allows to store numbers between 0 and
-slightly more than 4 billion (on most systems, where integers are 32-bit). In
-fact, this is what types::global_dof_index is.
+deal.II defines a number of integral %types via alias in namespace types. In
+particular, in this program you will see types::global_dof_index in a couple of
+places: an integer type that is used to denote the <i>global</i> index of a
+degree of freedom, i.e., the index of a particular degree of freedom within the
+DoFHandler object that is defined on top of a triangulation (as opposed to the
+index of a particular degree of freedom within a particular cell). For the
+current program (as well as almost all of the tutorial programs), you will have
+a few thousand to maybe a few million unknowns globally (and, for $Q_1$
+elements, you will have 4 <i>locally on each cell</i> in 2d and 8 in 3d).
+Consequently, a data type that allows to store sufficiently large numbers for
+global DoF indices is <code>unsigned int</code> given that it allows to store
+numbers between 0 and slightly more than 4 billion (on most systems, where
+integers are 32-bit). In fact, this is what types::global_dof_index is.
 
 So, why not just use <code>unsigned int</code> right away? deal.II used to do
 this until version 7.3. However, deal.II supports very large computations (via
@@ -392,13 +391,12 @@ global indices of those degrees of freedom locally defined on the current
 cell" -- but variables that hold this information are universally named this
 way throughout the library.
 
-@note types::global_dof_index is not the only type defined in this
-namespace. Rather, there is a whole family, including types::subdomain_id,
-types::boundary_id, and types::material_id. All of these are
-<code>typedef</code>s for integer data types but, as explained above, they are
-used throughout the library so that (i) the intent of a variable becomes more
-easily discerned, and (ii) so that it becomes possible to change the actual
-type to a larger one if necessary without having to go through the entire
-library and figure out whether a particular use of <code>unsigned int</code>
-corresponds to, say, a material indicator.
+@note types::global_dof_index is not the only type defined in this namespace.
+Rather, there is a whole family, including types::subdomain_id,
+types::boundary_id, and types::material_id. All of these are alias for integer
+data types but, as explained above, they are used throughout the library so that
+(i) the intent of a variable becomes more easily discerned, and (ii) so that it
+becomes possible to change the actual type to a larger one if necessary without
+having to go through the entire library and figure out whether a particular use
+of <code>unsigned int</code> corresponds to, say, a material indicator.
 
index 5eec2c403cfef4dc8d669af00182c2915123aa65..73f6de2ff53c09627a4e503e094d0ab216541a6f 100644 (file)
@@ -2308,8 +2308,8 @@ namespace Step32
 
     const QGauss<dim> quadrature_formula(parameters.stokes_velocity_degree + 1);
 
-    typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-      CellFilter;
+    using CellFilter =
+      FilteredIterator<typename DoFHandler<2>::active_cell_iterator>;
 
     WorkStream::run(
       CellFilter(IteratorFilters::LocallyOwnedCell(),
@@ -2497,8 +2497,8 @@ namespace Step32
 
     const QGauss<dim> quadrature_formula(parameters.stokes_velocity_degree + 1);
 
-    typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-      CellFilter;
+    using CellFilter =
+      FilteredIterator<typename DoFHandler<2>::active_cell_iterator>;
 
     WorkStream::run(
       CellFilter(IteratorFilters::LocallyOwnedCell(),
@@ -2610,8 +2610,8 @@ namespace Step32
 
     const QGauss<dim> quadrature_formula(parameters.temperature_degree + 2);
 
-    typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-      CellFilter;
+    using CellFilter =
+      FilteredIterator<typename DoFHandler<2>::active_cell_iterator>;
 
     WorkStream::run(
       CellFilter(IteratorFilters::LocallyOwnedCell(),
@@ -2878,8 +2878,8 @@ namespace Step32
     const double global_entropy_variation =
       get_entropy_variation(average_temperature);
 
-    typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-      CellFilter;
+    using CellFilter =
+      FilteredIterator<typename DoFHandler<2>::active_cell_iterator>;
 
     WorkStream::run(
       CellFilter(IteratorFilters::LocallyOwnedCell(),
index 13001144caaceea800bc288b348703c01346c8fb..f1b667af51a429175044aaa75153f7f3c82dae66 100644 (file)
@@ -250,7 +250,7 @@ used:
 #include <Sacado.hpp>
 #include <iostream>
 
-typedef Sacado::Fad::DFad<double> fad_double;
+using fad_double = Sacado::Fad::DFad<double>;
 
 main() {
 
index 75ab69cfb3725c9b375fa1f99fc044c577af6462..91c45085592eb973e4c7169b42ab49d24a0619d7 100644 (file)
@@ -872,8 +872,8 @@ namespace Step35
   // and compressing it. It is important to notice here that the gradient
   // operator acts from the pressure space into the velocity space, so we have
   // to deal with two different finite element spaces. To keep the loops
-  // synchronized, we use the <code>typedef</code>'s that we have defined
-  // before, namely <code>PairedIterators</code> and <code>IteratorPair</code>.
+  // synchronized, we use the alias that we have defined before, namely
+  // <code>PairedIterators</code> and <code>IteratorPair</code>.
   template <int dim>
   void NavierStokesProjection<dim>::initialize_gradient_operator()
   {
index 1c8e094427bb669d806c2b221fc6c6fc2d6ec68a..aeed9f0c40f63ba4bbcadd90f19d5f8a6adcc54a 100644 (file)
@@ -246,7 +246,7 @@ namespace Step37
         Base<dim, LinearAlgebra::distributed::Vector<number>>
   {
   public:
-    typedef number value_type;
+    using value_type = number;
 
     LaplaceOperator();
 
@@ -719,13 +719,13 @@ namespace Step37
     DoFHandler<dim> dof_handler;
 
     ConstraintMatrix constraints;
-    typedef LaplaceOperator<dim, degree_finite_element, double>
-                     SystemMatrixType;
+    using SystemMatrixType =
+      LaplaceOperator<dim, degree_finite_element, double>;
     SystemMatrixType system_matrix;
 
     MGConstrainedDoFs mg_constrained_dofs;
-    typedef LaplaceOperator<dim, degree_finite_element, float> LevelMatrixType;
-    MGLevelObject<LevelMatrixType>                             mg_matrices;
+    using LevelMatrixType = LaplaceOperator<dim, degree_finite_element, float>;
+    MGLevelObject<LevelMatrixType> mg_matrices;
 
     LinearAlgebra::distributed::Vector<double> solution;
     LinearAlgebra::distributed::Vector<double> system_rhs;
@@ -1014,9 +1014,9 @@ namespace Step37
     // methods. The former involves only local communication between neighbors
     // in the (coarse) mesh, whereas the latter requires global communication
     // over all processors.
-    typedef PreconditionChebyshev<LevelMatrixType,
-                                  LinearAlgebra::distributed::Vector<float>>
-      SmootherType;
+    using SmootherType =
+      PreconditionChebyshev<LevelMatrixType,
+                            LinearAlgebra::distributed::Vector<float>>;
     mg::SmootherRelaxation<SmootherType,
                            LinearAlgebra::distributed::Vector<float>>
                                                          mg_smoother;
index e16bee4156b3efb1968db0242cea5cb6eea46379..910cd3856df36ecfa0222228b21f0779c03fe293 100644 (file)
@@ -449,7 +449,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
@@ -730,8 +730,8 @@ namespace Step39
     // While transfer and coarse grid solver are pretty much generic, more
     // flexibility is offered for the smoother. First, we choose Gauss-Seidel
     // as our smoothing method.
-    GrowingVectorMemory<Vector<double>>                mem;
-    typedef PreconditionSOR<SparseMatrix<double>>      RELAXATION;
+    GrowingVectorMemory<Vector<double>> mem;
+    using RELAXATION = PreconditionSOR<SparseMatrix<double>>;
     mg::SmootherRelaxation<RELAXATION, Vector<double>> mg_smoother;
     RELAXATION::AdditionalData                         smoother_data(1.);
     mg_smoother.initialize(mg_matrix, smoother_data);
index 6ed0e30e0e2c5244740d396f89e65245e05ad752..366a35004893ec1c56364e167a3b3e6e01be1fe6 100644 (file)
@@ -140,7 +140,7 @@ in the @ref distributed documentation module.
 to throw at it, and for as large a problem as you have the memory and patience
 to solve. However, there <i>is</i> a limit: the number of unknowns can not
 exceed the largest number that can be stored with an object of type
-types::global_dof_index. By default, this is a typedef for <code>unsigned
+types::global_dof_index. By default, this is an alias for <code>unsigned
 int</code>, which on most machines today is a 32-bit integer, limiting you to
 some 4 billion (in reality, since this program uses PETSc, you will be limited
 to half that as PETSc uses signed integers). However, this can be changed
index 2e2d9b7d173c5aeed763f6324a5f8f2cc811efbe..4e5904b0ce67c6794f936bab0513bf4cbed14e48 100644 (file)
@@ -122,8 +122,8 @@ namespace Step50
     FE_Q<dim>                                 fe;
     DoFHandler<dim>                           mg_dof_handler;
 
-    typedef LA::MPI::SparseMatrix matrix_t;
-    typedef LA::MPI::Vector       vector_t;
+    using matrix_t = LA::MPI::SparseMatrix;
+    using vector_t = LA::MPI::Vector;
 
     matrix_t system_matrix;
 
@@ -726,8 +726,7 @@ namespace Step50
     // SOR, Jacobi or Richardson method). The MGSmootherPrecondition
     // class provides support for this kind of smoother. Here, we opt
     // for the application of a single SOR iteration. To this end, we
-    // define an appropriate <code>typedef</code> and then setup a
-    // smoother object.
+    // define an appropriate alias and then setup a smoother object.
     //
     // The last step is to initialize the smoother object with our
     // level matrices and to set some smoothing parameters.  The
@@ -751,7 +750,7 @@ namespace Step50
     // preconditioner make sure that we get a
     // symmetric operator even for nonsymmetric
     // smoothers:
-    typedef LA::MPI::PreconditionJacobi                  Smoother;
+    using Smoother = LA::MPI::PreconditionJacobi;
     MGSmootherPrecondition<matrix_t, Smoother, vector_t> mg_smoother;
     mg_smoother.initialize(mg_matrices, Smoother::AdditionalData(0.5));
     mg_smoother.set_steps(2);
index 8af758535a040d92796672db48f1573dfbfaff01..e417e727e5fbd7c6b621b395ac8a49ec0e2a7610 100644 (file)
@@ -625,9 +625,8 @@ namespace Step55
     }
 
     // The InverseMatrix is used to solve for the mass matrix:
-    typedef LinearSolvers::InverseMatrix<LA::MPI::SparseMatrix,
-                                         LA::MPI::PreconditionAMG>
-                       mp_inverse_t;
+    using mp_inverse_t = LinearSolvers::InverseMatrix<LA::MPI::SparseMatrix,
+                                                      LA::MPI::PreconditionAMG>;
     const mp_inverse_t mp_inverse(preconditioner_matrix.block(1, 1), prec_S);
 
     // This constructs the block preconditioner based on the preconditioners
index 8490615be93b8957b8f8cc2800d0793d40b73d68..f262c6182b12bd6caf3b4af2028b2ce60cd109da 100644 (file)
@@ -896,7 +896,7 @@ namespace Step56
         MGCoarseGridHouseholder<> coarse_grid_solver;
         coarse_grid_solver.initialize(coarse_matrix);
 
-        typedef PreconditionSOR<SparseMatrix<double>>    Smoother;
+        using Smoother = PreconditionSOR<SparseMatrix<double>>;
         mg::SmootherRelaxation<Smoother, Vector<double>> mg_smoother;
         mg_smoother.initialize(mg_matrices);
         mg_smoother.set_steps(2);
index d31b000cc6c952de2fe0faef9b469ae396549660..6e87415d000c9e19da99af7bd513ad457c1e8881 100644 (file)
@@ -175,7 +175,7 @@ namespace Step59
   class LaplaceOperator : public Subscriptor
   {
   public:
-    typedef number value_type;
+    using value_type = number;
 
     LaplaceOperator() = default;
 
@@ -235,7 +235,7 @@ namespace Step59
   class PreconditionBlockJacobi
   {
   public:
-    typedef number value_type;
+    using value_type = number;
 
     void clear()
     {
@@ -929,11 +929,11 @@ namespace Step59
     FE_DGQHermite<dim> fe;
     DoFHandler<dim>    dof_handler;
 
-    typedef LaplaceOperator<dim, fe_degree, double> SystemMatrixType;
-    SystemMatrixType                                system_matrix;
+    using SystemMatrixType = LaplaceOperator<dim, fe_degree, double>;
+    SystemMatrixType system_matrix;
 
-    typedef LaplaceOperator<dim, fe_degree, float> LevelMatrixType;
-    MGLevelObject<LevelMatrixType>                 mg_matrices;
+    using LevelMatrixType = LaplaceOperator<dim, fe_degree, float>;
+    MGLevelObject<LevelMatrixType> mg_matrices;
 
     LinearAlgebra::distributed::Vector<double> solution;
     LinearAlgebra::distributed::Vector<double> system_rhs;
@@ -1220,11 +1220,10 @@ namespace Step59
                  << " s\n";
     time.restart();
 
-    typedef PreconditionChebyshev<
-      LevelMatrixType,
-      LinearAlgebra::distributed::Vector<float>,
-      PreconditionBlockJacobi<dim, fe_degree, float>>
-      SmootherType;
+    using SmootherType =
+      PreconditionChebyshev<LevelMatrixType,
+                            LinearAlgebra::distributed::Vector<float>,
+                            PreconditionBlockJacobi<dim, fe_degree, float>>;
     mg::SmootherRelaxation<SmootherType,
                            LinearAlgebra::distributed::Vector<float>>
                                                          mg_smoother;

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.