]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Replace 'typedef' by 'using' in the test suite. 11851/head
authorWolfgang Bangerth <bangerth@colostate.edu>
Fri, 5 Mar 2021 02:20:36 +0000 (03:20 +0100)
committerWolfgang Bangerth <bangerth@colostate.edu>
Fri, 5 Mar 2021 02:20:36 +0000 (03:20 +0100)
346 files changed:
tests/ad_common_tests/helper_scalar_coupled_2_components_01.h
tests/ad_common_tests/helper_scalar_coupled_2_components_02.h
tests/ad_common_tests/helper_scalar_coupled_2_components_03.h
tests/ad_common_tests/helper_scalar_coupled_2_components_04.h
tests/ad_common_tests/helper_scalar_coupled_2_components_05.h
tests/ad_common_tests/helper_scalar_coupled_2_components_06.h
tests/ad_common_tests/helper_scalar_coupled_2_components_06a.h
tests/ad_common_tests/helper_scalar_coupled_2_components_07.h
tests/ad_common_tests/helper_scalar_coupled_2_components_08.h
tests/ad_common_tests/helper_scalar_coupled_3_components_01.h
tests/ad_common_tests/helper_scalar_coupled_3_components_01_tapeless_only.h
tests/ad_common_tests/helper_scalar_single_component_01.h
tests/ad_common_tests/helper_scalar_single_component_02.h
tests/ad_common_tests/helper_scalar_single_component_03.h
tests/ad_common_tests/helper_scalar_single_component_04.h
tests/ad_common_tests/helper_vector_1_indep_1_dep_vars_01.h
tests/ad_common_tests/helper_vector_1_indep_2_dep_vars_01.h
tests/ad_common_tests/helper_vector_2_indep_1_dep_vars_01.h
tests/ad_common_tests/helper_vector_2_indep_2_dep_vars_01.h
tests/ad_common_tests/physics_functions_01.h
tests/ad_common_tests/physics_functions_02.h
tests/ad_common_tests/physics_functions_03.h
tests/ad_common_tests/step-44-helper_res_lin_01.h
tests/ad_common_tests/step-44-helper_scalar_01.h
tests/ad_common_tests/step-44-helper_var_form_01.h
tests/ad_common_tests/step-44-helper_vector_01.h
tests/ad_common_tests/symmetric_tensor_functions_01.h
tests/ad_common_tests/symmetric_tensor_functions_02.h
tests/ad_common_tests/symmetric_tensor_functions_03.h
tests/ad_common_tests/symmetric_tensor_functions_04.h
tests/ad_common_tests/tensor_functions_01.h
tests/ad_common_tests/tensor_functions_02.h
tests/adolc/helper_retaping_01.cc
tests/adolc/helper_retaping_02.cc
tests/adolc/helper_retaping_03.cc
tests/adolc/helper_scalar_failure_01.cc
tests/adolc/helper_scalar_failure_02.cc
tests/adolc/helper_scalar_failure_03.cc
tests/adolc/helper_scalar_failure_04.cc
tests/adolc/helper_scalar_failure_05.cc
tests/adolc/helper_tape_index_01.cc
tests/adolc/tensor_ops_01.cc
tests/adolc/tensor_ops_02.cc
tests/arpack/parpack_advection_diffusion_trilinos.cc
tests/arpack/step-36_parpack_mf.cc
tests/arpack/step-36_parpack_mf_02.cc
tests/arpack/step-36_parpack_mf_03.cc
tests/arpack/step-36_parpack_trilinos.cc
tests/base/aligned_vector_01.cc
tests/base/aligned_vector_02.cc
tests/base/aligned_vector_03.cc
tests/base/aligned_vector_move.cc
tests/base/anisotropic_2.cc
tests/base/derivative_forms_01.cc
tests/base/mpi_some_to_some_02.cc
tests/base/scalar_01.cc
tests/base/vectorization_02.cc
tests/bits/christian_1.cc
tests/bits/iterators_01.cc
tests/bits/periodic_flux_coupling_01.cc
tests/bits/solver_01.cc
tests/bits/step-13.cc
tests/bits/step-14.cc
tests/bits/step-16.cc
tests/bits/step-4_dg_periodic.cc
tests/bits/step-4_dg_periodic_coupling.cc
tests/cuda/matrix_free_initialize_vector.cu
tests/cuda/matrix_free_matrix_vector_10.cu
tests/cuda/matrix_free_matrix_vector_10a.cu
tests/cuda/matrix_free_matrix_vector_19.cu
tests/cuda/matrix_free_matrix_vector_25.cu
tests/cuda/matrix_free_reinit_01.cu
tests/cuda/precondition_03.cu
tests/distributed_grids/2d_refinement_10.cc
tests/distributed_grids/3d_refinement_12.cc
tests/distributed_grids/grid_tools_exchange_cell_data_01.cc
tests/distributed_grids/grid_tools_exchange_cell_data_02.cc
tests/distributed_grids/grid_tools_exchange_cell_data_03.cc
tests/distributed_grids/grid_tools_exchange_cell_data_04.cc
tests/distributed_grids/intergrid_transfer_representation_parallel.cc
tests/fail/hp-step-14.cc
tests/fe/fe_enriched_color_01.cc
tests/fe/fe_q_dg0.cc
tests/fe/fe_rannacher_turek_01.cc
tests/fe/fe_values_view_get_function_from_local_dof_values_01.cc
tests/fe/fe_values_view_get_function_from_local_dof_values_02.cc
tests/feinterface/step-12.cc
tests/gla/block_mat_02.cc
tests/gla/block_mat_03.cc
tests/gla/gla.h
tests/gla/mat_04.cc
tests/grid/filtered_iterator.cc
tests/grid/filtered_iterator_02.cc
tests/grid/filtered_iterator_03.cc
tests/grid/filtered_iterator_04.cc
tests/grid/get_finest_common_cells_01.cc
tests/grid/get_finest_common_cells_02.cc
tests/grid/get_finest_common_cells_03.cc
tests/grid/get_finest_common_cells_04.cc
tests/grid/grid_tools_05.cc
tests/grid/grid_tools_06.cc
tests/grid/grid_tools_active_cell_layer_within_distance_01.cc
tests/grid/grid_tools_active_cell_layer_within_distance_02.cc
tests/grid/grid_tools_bounding_box_01.cc
tests/grid/grid_tools_bounding_box_02.cc
tests/grid/grid_tools_compute_mesh_predicate_bounding_box_1.cc
tests/grid/grid_tools_halo_layer_01.cc
tests/grid/grid_tools_halo_layer_02.cc
tests/grid/grid_tools_halo_layer_03.cc
tests/grid/grid_tools_halo_layer_04.cc
tests/grid/grid_tools_halo_layer_05.cc
tests/grid/grid_tools_halo_layer_ghost_cells.cc
tests/grid/move_constructor.cc
tests/hp/step-13.cc
tests/integrators/cells_and_faces_01.cc
tests/integrators/empty_info.h
tests/integrators/functional_01.cc
tests/integrators/mesh_worker_01.cc
tests/integrators/mesh_worker_matrix_01.cc
tests/lac/block_linear_operator_05.cc
tests/lac/constraints_hanging_nodes_bc.cc
tests/lac/diagonal_matrix_02.cc
tests/lac/linear_operator_01.cc
tests/lac/linear_operator_01a.cc
tests/lac/linear_operator_04a.cc
tests/lac/linear_operator_08.cc
tests/lac/linear_operator_09.cc
tests/lac/linear_operator_10.cc
tests/lac/linear_operator_10a.cc
tests/lac/linear_operator_11.cc
tests/lac/linear_operator_12.cc
tests/lac/linear_operator_12a.cc
tests/lac/linear_operator_13.cc
tests/lac/linear_operator_14.cc
tests/lac/linear_operator_18.cc
tests/lac/qr.cc
tests/lac/qr_02.cc
tests/lac/qr_03.cc
tests/lac/qr_04.cc
tests/lac/qr_05.cc
tests/lac/qr_06.cc
tests/lac/qr_07.cc
tests/lac/qr_08.cc
tests/lac/qr_09.cc
tests/lac/qr_10.cc
tests/lac/schur_complement_04.cc
tests/matrix_free/advect_1d.cc
tests/matrix_free/advect_1d_system.cc
tests/matrix_free/advect_1d_vectorization_mask.cc
tests/matrix_free/compare_faces_by_cells.cc
tests/matrix_free/copy_feevaluation.cc
tests/matrix_free/estimate_condition_number_mass.cc
tests/matrix_free/faces_value_optimization.cc
tests/matrix_free/faces_value_optimization_02.cc
tests/matrix_free/get_functions_gl.cc
tests/matrix_free/get_functions_mappingq.cc
tests/matrix_free/get_functions_multife.cc
tests/matrix_free/get_functions_multife2.cc
tests/matrix_free/get_functions_notempl.cc
tests/matrix_free/get_functions_q_hierarchical.cc
tests/matrix_free/get_functions_rect.cc
tests/matrix_free/get_functions_variants.cc
tests/matrix_free/get_functions_variants_gl.cc
tests/matrix_free/integrate_functions.cc
tests/matrix_free/integrate_functions_multife.cc
tests/matrix_free/integrate_functions_multife2.cc
tests/matrix_free/laplace_operator_01.cc
tests/matrix_free/laplace_operator_02.cc
tests/matrix_free/laplace_operator_03.cc
tests/matrix_free/mass_operator_01.cc
tests/matrix_free/mass_operator_02.cc
tests/matrix_free/mass_operator_03.cc
tests/matrix_free/mass_operator_04.cc
tests/matrix_free/matrix_vector_10.cc
tests/matrix_free/matrix_vector_11.cc
tests/matrix_free/matrix_vector_12.cc
tests/matrix_free/matrix_vector_13.cc
tests/matrix_free/matrix_vector_19.cc
tests/matrix_free/matrix_vector_20.cc
tests/matrix_free/matrix_vector_21.cc
tests/matrix_free/matrix_vector_22.cc
tests/matrix_free/matrix_vector_23.cc
tests/matrix_free/matrix_vector_24.cc
tests/matrix_free/matrix_vector_blocks.cc
tests/matrix_free/matrix_vector_curl.cc
tests/matrix_free/matrix_vector_div.cc
tests/matrix_free/matrix_vector_faces_common.h
tests/matrix_free/matrix_vector_hp.cc
tests/matrix_free/matrix_vector_hp_no_template.cc
tests/matrix_free/matrix_vector_hp_parallel_01.cc
tests/matrix_free/matrix_vector_large_degree_02.cc
tests/matrix_free/matrix_vector_mf.h
tests/matrix_free/matrix_vector_mg.cc
tests/matrix_free/matrix_vector_stokes.cc
tests/matrix_free/matrix_vector_stokes_base.cc
tests/matrix_free/matrix_vector_stokes_flux.cc
tests/matrix_free/matrix_vector_stokes_noflux.cc
tests/matrix_free/matrix_vector_stokes_notempl.cc
tests/matrix_free/matrix_vector_stokes_onedof.cc
tests/matrix_free/matrix_vector_stokes_qdg0.cc
tests/matrix_free/matrix_vector_stokes_qdg0b.cc
tests/matrix_free/multigrid_dg_periodic.cc
tests/matrix_free/multigrid_dg_sip_01.cc
tests/matrix_free/multigrid_dg_sip_02.cc
tests/matrix_free/parallel_multigrid.cc
tests/matrix_free/parallel_multigrid_02.cc
tests/matrix_free/parallel_multigrid_adaptive_01.cc
tests/matrix_free/parallel_multigrid_adaptive_02.cc
tests/matrix_free/parallel_multigrid_adaptive_03.cc
tests/matrix_free/parallel_multigrid_adaptive_04.cc
tests/matrix_free/parallel_multigrid_adaptive_05.cc
tests/matrix_free/parallel_multigrid_adaptive_06.cc
tests/matrix_free/parallel_multigrid_adaptive_06ref.cc
tests/matrix_free/parallel_multigrid_adaptive_07.cc
tests/matrix_free/parallel_multigrid_adaptive_08.cc
tests/matrix_free/parallel_multigrid_fullydistributed.cc
tests/matrix_free/parallel_multigrid_mf.cc
tests/matrix_free/parallel_multigrid_mf_02.cc
tests/matrix_free/quadrature_points.cc
tests/matrix_free/step-37.cc
tests/matrix_free/stokes_computation.cc
tests/meshworker/mesh_loop_02.cc
tests/meshworker/mesh_loop_03.cc
tests/meshworker/mesh_loop_08.cc
tests/meshworker/mesh_loop_gmg_01.cc
tests/meshworker/mesh_loop_mpi_01.cc
tests/meshworker/scratch_data_01.cc
tests/meshworker/scratch_data_02.cc
tests/meshworker/scratch_data_03.cc
tests/meshworker/scratch_data_04.cc
tests/meshworker/scratch_data_05.cc
tests/meshworker/scratch_data_06.cc
tests/meshworker/scratch_data_07.cc
tests/meshworker/scratch_data_08.cc
tests/meshworker/step-11-mesh_loop.cc
tests/meshworker/step-50-mesh_loop.cc
tests/mpi/flux_edge_01.cc
tests/mpi/mesh_worker_01.cc
tests/mpi/mesh_worker_02.cc
tests/mpi/mesh_worker_03.cc
tests/mpi/mesh_worker_04.cc
tests/mpi/mesh_worker_05.cc
tests/mpi/mesh_worker_matrix_01.cc
tests/mpi/multigrid_adaptive.cc
tests/mpi/multigrid_uniform.cc
tests/mpi/parallel_block_vector_05.cc
tests/mpi/parallel_block_vector_06.cc
tests/mpi/parallel_block_vector_07.cc
tests/mpi/parallel_block_vector_08.cc
tests/mpi/parallel_block_vector_09.cc
tests/mpi/parallel_block_vector_10.cc
tests/mpi/parallel_block_vector_11.cc
tests/mpi/parallel_block_vector_12.cc
tests/mpi/periodic_neighbor_01.cc
tests/mpi/periodicity_04.cc
tests/mpi/step-37.cc
tests/mpi/step-39-block.cc
tests/mpi/step-39.cc
tests/mpi/torus.cc
tests/mpi/tria_signals_01.cc
tests/mpi/tria_signals_02.cc
tests/mpi/tria_signals_03.cc
tests/mpi/tria_signals_04.cc
tests/mpi/tria_signals_05.cc
tests/mpi/tria_signals_06.cc
tests/multigrid/cycles.cc
tests/multigrid/events_01.cc
tests/multigrid/mg_coarse_01.cc
tests/multigrid/mg_renumbered_01.cc
tests/multigrid/mg_renumbered_02.cc
tests/multigrid/mg_renumbered_03.cc
tests/multigrid/step-16-02.cc
tests/multigrid/step-16-03.cc
tests/multigrid/step-16-04.cc
tests/multigrid/step-16-05.cc
tests/multigrid/step-16-06.cc
tests/multigrid/step-16-07.cc
tests/multigrid/step-16-08.cc
tests/multigrid/step-16-50-mpi-linear-operator.cc
tests/multigrid/step-16-50-mpi-smoother.cc
tests/multigrid/step-16-50-mpi.cc
tests/multigrid/step-16-50-serial.cc
tests/multigrid/step-16-bdry1.cc
tests/multigrid/step-16.cc
tests/multigrid/step-39-02.cc
tests/multigrid/step-39-02a.cc
tests/multigrid/step-39-03.cc
tests/multigrid/step-39.cc
tests/multigrid/step-50_01.cc
tests/multigrid/step-50_02.cc
tests/multigrid/transfer_04.cc
tests/multigrid/transfer_04a.cc
tests/multigrid/transfer_04b.cc
tests/optimization/bfgs_03.cc
tests/optimization/bfgs_04.cc
tests/optimization/bfgs_05.cc
tests/optimization/bfgs_05b.cc
tests/parameter_handler/patterns_13.cc
tests/parameter_handler/patterns_14.cc
tests/parameter_handler/patterns_15.cc
tests/parameter_handler/patterns_16.cc
tests/petsc/52.cc
tests/petsc/67.cc
tests/petsc/69.cc
tests/petsc/parallel_sparse_matrix_01.cc
tests/physics/notation-kelvin_01.cc
tests/physics/notation-kelvin_02.cc
tests/rol/vector_adaptor_02.cc
tests/sacado/ad_number_traits_03.cc
tests/sacado/sacado_product_type_01.cc
tests/sacado/sacado_product_type_02.cc
tests/sacado/sacado_product_type_03.cc
tests/sacado/sacado_product_type_04.cc
tests/sacado/sacado_product_type_05.cc
tests/sacado/sacado_product_type_06.cc
tests/sacado/sacado_product_type_07.cc
tests/sacado/sacado_product_type_08.cc
tests/sacado/sacado_product_type_09.cc
tests/sacado/zero_val_nonzero_deriv_01.cc
tests/sundials/arkode_01.cc
tests/sundials/arkode_02.cc
tests/sundials/arkode_04.cc
tests/sundials/arkode_05.cc
tests/sundials/arkode_06.cc
tests/sundials/arkode_07.cc
tests/sundials/arkode_08.cc
tests/sundials/ida_01.cc
tests/sundials/kinsol_01.cc
tests/symengine/sd_common_tests/batch_optimizer_01.h
tests/symengine/sd_common_tests/batch_optimizer_02.h
tests/symengine/sd_common_tests/batch_optimizer_04.h
tests/symengine/sd_common_tests/batch_optimizer_07.h
tests/symengine/symengine_number_type_02.cc
tests/symengine/symengine_tensor_operations_02.cc
tests/tensors/symmetric_tensor_24.cc
tests/tensors/tensor_24.cc
tests/tensors/tensor_25.cc
tests/tensors/tensor_31.cc
tests/trilinos/assemble_matrix_parallel_02.cc
tests/trilinos/assemble_matrix_parallel_03.cc
tests/trilinos/assemble_matrix_parallel_04.cc
tests/trilinos/assemble_matrix_parallel_05.cc
tests/trilinos/assemble_matrix_parallel_06.cc
tests/trilinos/assemble_matrix_parallel_07.cc
tests/trilinos/parallel_block_vector_copy_01.cc
tests/vector_tools/interpolate_with_material_id_01.cc

index c6185076fd3939f6dbc09db9a184fcd889e8003b..4e2438c182399f2406652295b02e2db259fcb4ec 100644 (file)
@@ -86,9 +86,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_scalar_scalar_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Scalar + Scalar (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -100,7 +100,7 @@ test_scalar_scalar_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestScalarScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestScalarScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -191,8 +191,8 @@ test_scalar_scalar_coupled()
             << "extracted Dpsi (s2): " << dpsi_ds2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestScalarScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestScalarScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   Assert(std::abs(psi - func::psi(s1, s2)) < tol,
          ExcMessage("No match for function value."));
index 447a06cbcdb3e102cc75b93f25dc2e4a0b970333..df2ca432a07eec6062ba0ad4aa22ea740ac667b9 100644 (file)
@@ -88,9 +88,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_vector_scalar_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Vector + Scalar (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -102,7 +102,7 @@ test_vector_scalar_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestVectorScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestVectorScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -196,8 +196,8 @@ test_vector_scalar_coupled()
             << "extracted Dpsi (s): " << dpsi_ds << "\n";
 
   // Verify the result
-  typedef FunctionsTestVectorScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestVectorScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   Assert(std::abs(psi - func::psi(v, s)) < tol,
          ExcMessage("No match for function value."));
index fbd91323cc14a5f54184601c670cbb060e1998df..cc625916979cdb39ce7d1528acb3e63ffc86497b 100644 (file)
@@ -96,9 +96,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_tensor_scalar_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Tensor + Scalar (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -110,7 +110,7 @@ test_tensor_scalar_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestTensorScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestTensorScalarCoupled<dim, ADNumberType>;
 
   const FEValuesExtractors::Tensor<2> t_dof(0);
   const FEValuesExtractors::Scalar    s_dof(
@@ -206,8 +206,8 @@ test_tensor_scalar_coupled()
   ;
 
   // Verify the result
-  typedef FunctionsTestTensorScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestTensorScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
 
   Assert(std::abs(psi - func::psi(t, s)) < tol,
index 8a432352f9aa032ae50f720e451d9288b4168735..d068e90f727a4d541f04fb6bdbb0cb89c6f45f95 100644 (file)
@@ -109,9 +109,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_vector_vector_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Vector + Vector (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -123,7 +123,7 @@ test_vector_vector_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestVectorVectorCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestVectorVectorCoupled<dim, ADNumberType>;
 
   const FEValuesExtractors::Vector v1_dof(0);
   const FEValuesExtractors::Vector v2_dof(
@@ -218,8 +218,8 @@ test_vector_vector_coupled()
             << "extracted Dpsi (v2): " << dpsi_dv2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestVectorVectorCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestVectorVectorCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
 
   Assert(std::abs(psi - func::psi(v1, v2)) < tol,
index 430f9fab5872a9fb10031728c42758576fd3ab46..07cb80cfee158d489f731a8e0ad994b595d8dc10 100644 (file)
@@ -149,9 +149,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_tensor_vector_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Tensor + Vector (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -163,7 +163,7 @@ test_tensor_vector_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestTensorVectorCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestTensorVectorCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -263,8 +263,8 @@ test_tensor_vector_coupled()
             << "extracted Dpsi (v): " << dpsi_dv << "\n";
 
   // Verify the result
-  typedef FunctionsTestTensorVectorCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestTensorVectorCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_dt:            " << dpsi_dt << std::endl;
   std::cout << "func::dpsi_dt(t,v): " << func::dpsi_dt(t, v) << std::endl;
index bb3cfa849b5edc9b6a453bd67d7819deeb92b97a..0333dabcb06d6794b4ae10926d4b1feed188ddec 100644 (file)
@@ -157,9 +157,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_symmetric_tensor_vector_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: SymmetricTensor + Vector (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -171,7 +171,7 @@ test_symmetric_tensor_vector_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestSymmetricTensorVectorCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSymmetricTensorVectorCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -271,8 +271,8 @@ test_symmetric_tensor_vector_coupled()
             << "extracted Dpsi (v): " << dpsi_dv << "\n";
 
   // Verify the result
-  typedef FunctionsTestSymmetricTensorVectorCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                            tol =
+  using func = FunctionsTestSymmetricTensorVectorCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_dt:            " << dpsi_dt << std::endl;
   std::cout << "func::dpsi_dt(t,v): " << func::dpsi_dt(t, v) << std::endl;
index 6f178471bb18e6da8dd51993a39dea6bb527bf4a..dabcd3b157772001c923cdc5dedeb3fbd47e7d43 100644 (file)
@@ -164,9 +164,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_symmetric_tensor_vector_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: SymmetricTensor + Vector (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -178,7 +178,7 @@ test_symmetric_tensor_vector_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestSymmetricTensorVectorCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSymmetricTensorVectorCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -278,8 +278,8 @@ test_symmetric_tensor_vector_coupled()
             << "extracted Dpsi (v): " << dpsi_dv << "\n";
 
   // Verify the result
-  typedef FunctionsTestSymmetricTensorVectorCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                            tol =
+  using func = FunctionsTestSymmetricTensorVectorCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_dt:            " << dpsi_dt << std::endl;
   std::cout << "func::dpsi_dt(t,v): " << func::dpsi_dt(t, v) << std::endl;
index 9bfcaea68de5c34a3430e468aa0b76d6ffacf975..ff9af10bee4f1b376274c5a1f385f50d12aee048 100644 (file)
@@ -169,9 +169,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_symmetric_tensor_tensor_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: SymmetricTensor + Tensor (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -183,7 +183,7 @@ test_symmetric_tensor_tensor_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestSymmetricTensorTensorCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSymmetricTensorTensorCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -284,8 +284,8 @@ test_symmetric_tensor_tensor_coupled()
             << "extracted Dpsi (t2): " << dpsi_dt2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestSymmetricTensorTensorCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                            tol =
+  using func = FunctionsTestSymmetricTensorTensorCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_dt1:            " << dpsi_dt1 << std::endl;
   std::cout << "func::dpsi_dt1(t1,t2): " << func::dpsi_dt1(t1, t2) << std::endl;
index 3a1a928c5adf2c98d73eb097d6d44400e0ecb3e1..ff2c6c02e413fc61616c75acd491453f0f871f21 100644 (file)
@@ -139,9 +139,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_symmetric_tensor_symmetric_tensor_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout
     << "*** Test variables: SymmetricTensor + SymmetricTensor (coupled), "
@@ -154,8 +154,8 @@ test_symmetric_tensor_symmetric_tensor_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestSymmetricTensorSymmetricTensorCoupled<dim, ADNumberType>
-    func_ad;
+  using func_ad =
+    FunctionsTestSymmetricTensorSymmetricTensorCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -256,9 +256,8 @@ test_symmetric_tensor_symmetric_tensor_coupled()
             << "extracted Dpsi (t2): " << dpsi_dt2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestSymmetricTensorSymmetricTensorCoupled<dim,
-                                                             ScalarNumberType>
-                                func;
+  using func =
+    FunctionsTestSymmetricTensorSymmetricTensorCoupled<dim, ScalarNumberType>;
   static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_dt1:            " << dpsi_dt1 << std::endl;
index d1859321dc8076536dc25798cecfdb67d43ee204..00c6cbaed7a892d9af5fdd29c01532629b1d0a1f 100644 (file)
@@ -221,9 +221,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_tensor_vector_scalar_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   const unsigned int this_mpi_process =
     Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
@@ -239,7 +239,7 @@ test_tensor_vector_scalar_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestTensorVectorScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestTensorVectorScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -354,8 +354,8 @@ test_tensor_vector_scalar_coupled()
         << "extracted Dpsi (s): " << dpsi_ds << "\n";
 
   // Verify the result
-  typedef FunctionsTestTensorVectorScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                         tol =
+  using func = FunctionsTestTensorVectorScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   Assert(std::abs(psi - func::psi(t, v, s)) < tol,
          ExcMessage("No match for function value."));
index 9333093d3c0f9d875c47577c3043c93764d6373b..a27b1440ccab56fdae678d75d4fab89df4eca904 100644 (file)
@@ -225,9 +225,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_tensor_vector_scalar_coupled()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   const unsigned int this_mpi_process =
     Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
@@ -243,7 +243,7 @@ test_tensor_vector_scalar_coupled()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestTensorVectorScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestTensorVectorScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -333,8 +333,8 @@ test_tensor_vector_scalar_coupled()
         << "extracted Dpsi (s): " << dpsi_ds << "\n";
 
   // Verify the result
-  typedef FunctionsTestTensorVectorScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                         tol =
+  using func = FunctionsTestTensorVectorScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   Assert(std::abs(psi - func::psi(t, v, s)) < tol,
          ExcMessage("No match for function value."));
index 41d37c9f197eb80e34bc4f895d7b7be7285483fa..b643a253fc36252e270f191cc236b917483bd9dd 100644 (file)
@@ -60,9 +60,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_scalar()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Scalar dof, "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -74,7 +74,7 @@ test_scalar()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestScalar<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestScalar<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -152,8 +152,8 @@ test_scalar()
     ad_helper.extract_gradient_component(Dpsi, s_dof);
 
   // Verify the result
-  typedef FunctionsTestScalar<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestScalar<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(s):     " << func::psi(s) << std::endl;
index 1d9c450a13997111c16e969d6f5bb5e9f27b57ae..0ea8185607e32424b40fbcc917642f516a66302f 100644 (file)
@@ -67,9 +67,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_vector()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Vector dof, "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -81,7 +81,7 @@ test_vector()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestVector<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestVector<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -163,8 +163,8 @@ test_vector()
     ad_helper.extract_gradient_component(Dpsi, v_dof);
 
   // Verify the result
-  typedef FunctionsTestVector<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestVector<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(v):     " << func::psi(v) << std::endl;
index 34661693da4815afc0fffa4318dd065aeef55f3d..ae93460bd6ce56c597f124f1dc20fbd254f13b8d 100644 (file)
@@ -77,9 +77,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_tensor()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Tensor dof, "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -91,7 +91,7 @@ test_tensor()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestTensor<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestTensor<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -174,8 +174,8 @@ test_tensor()
     ad_helper.extract_gradient_component(Dpsi, t_dof);
 
   // Verify the result
-  typedef FunctionsTestTensor<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestTensor<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(t):     " << func::psi(t) << std::endl;
index 11d16322f2f1bba852d69062b6749ebe1eb780d6..88bdf91737427816e63f0e932b1a5042091fc34f 100644 (file)
@@ -80,9 +80,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_symmetric_tensor()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: SymmetricTensor dof, "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -94,7 +94,7 @@ test_symmetric_tensor()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestSymmetricTensor<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSymmetricTensor<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -178,8 +178,8 @@ test_symmetric_tensor()
     ad_helper.extract_gradient_component(Dpsi, t_dof);
 
   // Verify the result
-  typedef FunctionsTestSymmetricTensor<dim, ScalarNumberType> func;
-  static const ScalarNumberType                               tol =
+  using func = FunctionsTestSymmetricTensor<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(t):     " << func::psi(t) << std::endl;
index a95c4bb2a1f4f954c05ac3b54ad9a164240c2feb..94eb17f0e717763632ff8d02c91f5c4323950fd4 100644 (file)
@@ -56,16 +56,16 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_AD_vector_jacobian()
 {
-  typedef AD::VectorFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::VectorFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Variables: 1 independent, 1 dependent, "
             << "dim = " << Utilities::to_string(dim) << ", "
             << "Type code: " << static_cast<int>(ad_type_code) << std::endl;
 
   // Function and its derivatives
-  typedef FunctionsTestScalar<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestScalar<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -143,8 +143,8 @@ test_AD_vector_jacobian()
   Dfuncs.print_formatted(std::cout, 3, true, 0, "0.0");
 
   // Verify the result
-  typedef FunctionsTestScalar<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestScalar<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "funcs[0]: " << funcs[0]
             << "\t func::f0(s[0])): " << func::f0(s[0]) << std::endl;
index fba99f1549a95f75161c9fdd0c6177b2a72ef20d..223a407fe308e7913d5f10a5573b1023d1a634dc 100644 (file)
@@ -68,16 +68,16 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_AD_vector_jacobian()
 {
-  typedef AD::VectorFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::VectorFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Variables: 1 independent, 2 dependent, "
             << "dim = " << Utilities::to_string(dim) << ", "
             << "Type code: " << static_cast<int>(ad_type_code) << std::endl;
 
   // Function and its derivatives
-  typedef FunctionsTestSquare<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSquare<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -155,8 +155,8 @@ test_AD_vector_jacobian()
   Dfuncs.print_formatted(std::cout, 3, true, 0, "0.0");
 
   // Verify the result
-  typedef FunctionsTestSquare<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestSquare<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "funcs[0]: " << funcs[0]
             << "\t func::f0(s[0])): " << func::f0(s[0]) << std::endl;
index 43ce745d5ede1d869d005a2210b4ac256970c24d..ee0c1dae4a0931f44b08248fc6875f26029b9c8a 100644 (file)
@@ -62,16 +62,16 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_AD_vector_jacobian()
 {
-  typedef AD::VectorFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::VectorFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Variables: 2 independent, 1 dependent, "
             << "dim = " << Utilities::to_string(dim) << ", "
             << "Type code: " << static_cast<int>(ad_type_code) << std::endl;
 
   // Function and its derivatives
-  typedef FunctionsTestSquare<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSquare<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -150,8 +150,8 @@ test_AD_vector_jacobian()
   Dfuncs.print_formatted(std::cout, 3, true, 0, "0.0");
 
   // Verify the result
-  typedef FunctionsTestSquare<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestSquare<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "funcs[0]: " << funcs[0]
             << "\t func::f0(s[0],s[1])): " << func::f0(s[0], s[1]) << std::endl;
index 4ce3c01ba59b5243882b436f2f5197a12b85a35c..4bd6f7203f00c20b9d71149ae28e09ed96095807 100644 (file)
@@ -80,16 +80,16 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_AD_vector_jacobian()
 {
-  typedef AD::VectorFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::VectorFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Variables: 2 independent, 2 dependent, "
             << "dim = " << Utilities::to_string(dim) << ", "
             << "Type code: " << static_cast<int>(ad_type_code) << std::endl;
 
   // Function and its derivatives
-  typedef FunctionsTestSquare<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSquare<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -169,8 +169,8 @@ test_AD_vector_jacobian()
   Dfuncs.print_formatted(std::cout, 3, true, 0, "0.0");
 
   // Verify the result
-  typedef FunctionsTestSquare<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestSquare<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "funcs[0]: " << funcs[0]
             << "\t func::f0(s[0],s[1])): " << func::f0(s[0], s[1]) << std::endl;
index ffb9a8584e978ac748f5eeaefed288216abb234b..9b53e6f07b8e3343fdd0ea628ad515f7e133c542 100644 (file)
@@ -36,8 +36,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_physics()
 {
-  typedef
-    typename AD::NumberTraits<number_t, ad_type_code>::ad_type ADNumberType;
+  using ADNumberType =
+    typename AD::NumberTraits<number_t, ad_type_code>::ad_type;
 
   std::cout << "*** Test physics functions: Kinematics, "
             << "dim = " << Utilities::to_string(dim) << ", "
index 4581e4f55064fbc46a42df700f740162006a06d0..3507e388818d2d8db79916a06df65f34ea48968e 100644 (file)
@@ -37,8 +37,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_physics()
 {
-  typedef
-    typename AD::NumberTraits<number_t, ad_type_code>::ad_type ADNumberType;
+  using ADNumberType =
+    typename AD::NumberTraits<number_t, ad_type_code>::ad_type;
 
   std::cout << "*** Test physics functions: Standard tensors, "
             << "dim = " << Utilities::to_string(dim) << ", "
index cb67d507d628365dad0bd3d901b03cdb40cb0fde..9acf932dcb894baf802dfe33be555e375d6494b8 100644 (file)
@@ -37,8 +37,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_physics()
 {
-  typedef
-    typename AD::NumberTraits<number_t, ad_type_code>::ad_type ADNumberType;
+  using ADNumberType =
+    typename AD::NumberTraits<number_t, ad_type_code>::ad_type;
 
   std::cout << "*** Test physics functions: Standard tensors, "
             << "dim = " << Utilities::to_string(dim) << ", "
index 1ec0a5903b5628d7ad0f6c9430e07d3e6430b417..3bdcfe12e3c319e6dd9f27c7893b5ba3addfc3c5 100644 (file)
@@ -1191,8 +1191,8 @@ namespace Step44
     Assert(n_dependent_variables == n_independent_variables,
            ExcMessage("Expect square system."));
 
-    typedef AD::ResidualLinearization<ad_type_code, number_t> ADHelper;
-    typedef typename ADHelper::ad_type                        ADNumberType;
+    using ADHelper     = AD::ResidualLinearization<ad_type_code, number_t>;
+    using ADNumberType = typename ADHelper::ad_type;
     ADHelper ad_helper(n_independent_variables, n_dependent_variables);
     ad_helper.set_tape_buffer_sizes(); // Increase the buffer size from the
                                        // default values
index e643e8e18fe404c344d978636b9f65fe1d92af34..31eb6320f1c9f013266c5878c53a3d9e4777fc8a 100644 (file)
@@ -578,8 +578,8 @@ namespace Step44
         const unsigned int n_independent_variables =
           SymmetricTensor<2, dim>::n_independent_components + 1 + 1;
 
-        typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-        typedef typename ADHelper::ad_type                      ADNumberType;
+        using ADHelper     = AD::ScalarFunction<dim, ad_type_code, number_t>;
+        using ADNumberType = typename ADHelper::ad_type;
         ADHelper ad_helper(n_independent_variables);
         ad_helper.set_tape_buffer_sizes(); // Increase the buffer size from the
                                            // default values
@@ -663,8 +663,8 @@ namespace Step44
         const FEValuesExtractors::Scalar J_dofs(0);
         const unsigned int               n_independent_variables = 1;
 
-        typedef typename AD::ScalarFunction<dim, ad_type_code, double>::ad_type
-                                                      ADNumberType;
+        using ADNumberType =
+          typename AD::ScalarFunction<dim, ad_type_code, double>::ad_type;
         AD::ScalarFunction<dim, ad_type_code, double> ad_helper(
           n_independent_variables);
         ad_helper.set_tape_buffer_sizes(); // Increase the buffer size from the
index f3e25ab0cdcb3a388377090c59fd0c11ea8321ed..f7484785f1dc7638f526f21a5c8663ab3b1c738a 100644 (file)
@@ -1154,8 +1154,8 @@ namespace Step44
 
     const unsigned int n_independent_variables = data.local_dof_indices.size();
 
-    typedef AD::EnergyFunctional<ad_type_code, number_t> ADHelper;
-    typedef typename ADHelper::ad_type                   ADNumberType;
+    using ADHelper     = AD::EnergyFunctional<ad_type_code, number_t>;
+    using ADNumberType = typename ADHelper::ad_type;
     ADHelper ad_helper(n_independent_variables);
     ad_helper.set_tape_buffer_sizes(); // Increase the buffer size from the
                                        // default values
index 4907f3caf9008ba8d2fc5611da607efe4e4fe9e8..73ce42fc22e5f4fc7136333f6f17ea1dafc5e783 100644 (file)
@@ -1193,8 +1193,8 @@ namespace Step44
     Assert(n_dependent_variables == n_independent_variables,
            ExcMessage("Expect square system."));
 
-    typedef AD::VectorFunction<dim, ad_type_code, number_t> ADHelper;
-    typedef typename ADHelper::ad_type                      ADNumberType;
+    using ADHelper     = AD::VectorFunction<dim, ad_type_code, number_t>;
+    using ADNumberType = typename ADHelper::ad_type;
     ADHelper ad_helper(n_independent_variables, n_dependent_variables);
     ad_helper.set_tape_buffer_sizes(); // Increase the buffer size from the
                                        // default values
index fe0dea4bf3b03d03310913449d8b35dc287fff24..89f0d0d9b2aac5afbc13a58630fdd6006fbea6c3 100644 (file)
@@ -33,8 +33,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_symmetric_tensor()
 {
-  typedef
-    typename AD::NumberTraits<number_t, ad_type_code>::ad_type ADNumberType;
+  using ADNumberType =
+    typename AD::NumberTraits<number_t, ad_type_code>::ad_type;
 
   std::cout << "*** Test SymmetricTensor functions, "
             << "dim = " << Utilities::to_string(dim) << ", "
index 2d150e47af3b71d1178b35f03b5015848cb69ebe..0e2bc7a8c2be27a08500989fe63009dfdb73fb0a 100644 (file)
@@ -98,9 +98,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_symmetric_tensor()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** dim = " << Utilities::to_string(dim) << ", "
             << "Type code: " << static_cast<int>(ad_type_code) << std::endl;
@@ -115,7 +115,7 @@ test_symmetric_tensor()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestSymmetricTensor<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestSymmetricTensor<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -199,8 +199,8 @@ test_symmetric_tensor()
     ad_helper.extract_gradient_component(Dpsi, t_dof);
 
   // Verify the result
-  typedef FunctionsTestSymmetricTensor<dim, ScalarNumberType> func;
-  static const ScalarNumberType                               tol =
+  using func = FunctionsTestSymmetricTensor<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(t):     " << func::psi(t) << std::endl;
index d6d013c061024dfb1dd0bc79858fc585e2b2ec3c..b020c87233f8cab600f4395238f4c7f3a34f94eb 100644 (file)
@@ -122,9 +122,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_NH(const bool nontrivial_initial_values)
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Standard definition of incompressible NeoHookean material, "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -138,7 +138,7 @@ test_NH(const bool nontrivial_initial_values)
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef IncompressibleNeoHookean<dim, ADNumberType> func_ad;
+  using func_ad = IncompressibleNeoHookean<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -223,8 +223,8 @@ test_NH(const bool nontrivial_initial_values)
     ad_helper.extract_gradient_component(Dpsi, C_dof);
 
   // Verify the result
-  typedef IncompressibleNeoHookean<dim, ScalarNumberType> func;
-  static const ScalarNumberType                           tol =
+  using func = IncompressibleNeoHookean<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(C):     " << func::psi(C) << std::endl;
@@ -255,9 +255,9 @@ void
 test_NH_eigen_energy(const enum SymmetricTensorEigenvectorMethod method,
                      const bool nontrivial_initial_values)
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout
     << "*** Principal stretch definition of incompressible NeoHookean material (from free energy function), "
@@ -273,7 +273,7 @@ test_NH_eigen_energy(const enum SymmetricTensorEigenvectorMethod method,
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef IncompressibleNeoHookeanPrincipalStretches<dim, ADNumberType> func_ad;
+  using func_ad = IncompressibleNeoHookeanPrincipalStretches<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -359,8 +359,8 @@ test_NH_eigen_energy(const enum SymmetricTensorEigenvectorMethod method,
     ad_helper.extract_gradient_component(Dpsi, C_dof);
 
   // Verify the result
-  typedef IncompressibleNeoHookean<dim, ScalarNumberType> func;
-  static const ScalarNumberType                           tol_val =
+  using func = IncompressibleNeoHookean<dim, ScalarNumberType>;
+  static const ScalarNumberType tol_val =
     (nontrivial_initial_values ?
        1e-6 :
        1e5 * std::numeric_limits<ScalarNumberType>::epsilon());
index 06026b1dc018996a74ac9c65bd093a31bea2fff6..11e83915b9492c96d07768da7f79137a28fef60e 100644 (file)
@@ -123,9 +123,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_NH(const bool nontrivial_initial_values)
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Standard definition of incompressible NeoHookean material, "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -139,7 +139,7 @@ test_NH(const bool nontrivial_initial_values)
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef IncompressibleNeoHookean<dim, ADNumberType> func_ad;
+  using func_ad = IncompressibleNeoHookean<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -224,8 +224,8 @@ test_NH(const bool nontrivial_initial_values)
     ad_helper.extract_gradient_component(Dpsi, C_dof);
 
   // Verify the result
-  typedef IncompressibleNeoHookean<dim, ScalarNumberType> func;
-  static const ScalarNumberType                           tol =
+  using func = IncompressibleNeoHookean<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(C):     " << func::psi(C) << std::endl;
@@ -256,9 +256,9 @@ void
 test_NH_eigen_stress(const enum SymmetricTensorEigenvectorMethod method,
                      const bool nontrivial_initial_values)
 {
-  typedef AD::VectorFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::VectorFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout
     << "*** Principal stretch definition of incompressible NeoHookean material (from stress), "
@@ -274,7 +274,7 @@ test_NH_eigen_stress(const enum SymmetricTensorEigenvectorMethod method,
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef IncompressibleNeoHookeanPrincipalStretches<dim, ADNumberType> func_ad;
+  using func_ad = IncompressibleNeoHookeanPrincipalStretches<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -368,8 +368,8 @@ test_NH_eigen_stress(const enum SymmetricTensorEigenvectorMethod method,
     ad_helper.extract_value_component(Dpsi, C_dof);
 
   // Verify the result
-  typedef IncompressibleNeoHookean<dim, ScalarNumberType> func;
-  static const ScalarNumberType                           tol_val =
+  using func = IncompressibleNeoHookean<dim, ScalarNumberType>;
+  static const ScalarNumberType tol_val =
     (nontrivial_initial_values ?
        1e-4 :
        1e6 * std::numeric_limits<ScalarNumberType>::epsilon());
index 57d172dfb4eac57e18cb2886da896abb5d6cdcf5..224e3857ccb3796cde9e174a177c791c00912af6 100644 (file)
@@ -32,8 +32,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_tensor()
 {
-  typedef
-    typename AD::NumberTraits<number_t, ad_type_code>::ad_type ADNumberType;
+  using ADNumberType =
+    typename AD::NumberTraits<number_t, ad_type_code>::ad_type;
 
   std::cout << "*** Test Tensor functions, "
             << "dim = " << Utilities::to_string(dim) << ", "
index a4da1168858cf2723e0d6688e0cd8954a7f3f2ad..6c3c74e5e7e295ac9d67292411725fcfff74c0bb 100644 (file)
@@ -93,9 +93,9 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 void
 test_tensor()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** dim = " << Utilities::to_string(dim) << ", "
             << "Type code: " << static_cast<int>(ad_type_code) << std::endl;
@@ -110,7 +110,7 @@ test_tensor()
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestTensor<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestTensor<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -193,8 +193,8 @@ test_tensor()
     ad_helper.extract_gradient_component(Dpsi, t_dof);
 
   // Verify the result
-  typedef FunctionsTestTensor<dim, ScalarNumberType> func;
-  static const ScalarNumberType                      tol =
+  using func = FunctionsTestTensor<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e5 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "psi:              " << psi << std::endl;
   std::cout << "func::psi(t):     " << func::psi(t) << std::endl;
index 64db8b3dcad3e4a47b6e71f47852a71128d651f6..fbd4472e802beadb4f6be7990cbf7f7a4a350475 100644 (file)
@@ -97,9 +97,9 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
                                    const number_t s2,
                                    const bool     overwrite_tape)
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Scalar + Scalar (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -113,7 +113,7 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestScalarScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestScalarScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -194,8 +194,8 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
             << "extracted Dpsi (s2): " << dpsi_ds2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestScalarScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestScalarScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e8 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_ds1:            " << dpsi_ds1 << std::endl;
   std::cout << "func::dpsi_ds1(s1,s2): " << func::dpsi_ds1(s1, s2) << std::endl;
index b0d093ea33d32990934f7b8b7d5e583fdaabda5f..5b16cb4a8aee9895e35d931e18bc85b372374457 100644 (file)
@@ -97,9 +97,9 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
                                    const number_t s2,
                                    const bool     overwrite_tape)
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Scalar + Scalar (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -113,7 +113,7 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestScalarScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestScalarScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -197,8 +197,8 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
             << "extracted Dpsi (s2): " << dpsi_ds2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestScalarScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestScalarScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e8 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_ds1:            " << dpsi_ds1 << std::endl;
   std::cout << "func::dpsi_ds1(s1,s2): " << func::dpsi_ds1(s1, s2) << std::endl;
index 97e746a304623b3c3d96c5d316adcaf1d1858cae..a20f08f40ebfaf473b7a95b35b8e4db127fa0a7f 100644 (file)
@@ -96,9 +96,9 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
                                    const number_t s2,
                                    const bool     clear_tapes)
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout << "*** Test variables: Scalar + Scalar (coupled), "
             << "dim = " << Utilities::to_string(dim) << ", "
@@ -111,7 +111,7 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestScalarScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestScalarScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -200,8 +200,8 @@ test_scalar_scalar_coupled_one_run(const number_t s1,
             << "extracted Dpsi (s2): " << dpsi_ds2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestScalarScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol =
+  using func = FunctionsTestScalarScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol =
     1e8 * std::numeric_limits<ScalarNumberType>::epsilon();
   std::cout << "dpsi_ds1:            " << dpsi_ds1 << std::endl;
   std::cout << "func::dpsi_ds1(s1,s2): " << func::dpsi_ds1(s1, s2) << std::endl;
index 7629711e6885ed7391d20d98d193091468073948..c3fbb39b9c3d1993c228bd9ad8f951b719134657 100644 (file)
@@ -39,8 +39,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 bool
 test_overlapping_ind_var_components()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
+  using ADHelper     = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType = typename ADHelper::ad_type;
 
   std::cout << "*** Test variables: Scalar + Scalar (coupled), "
             << (AD::ADNumberTraits<ADNumberType>::is_taped == true ? "Taped" :
index ec3ddbd82737aca7d529e449aff671a01b0a542f..65c785459833accc1c7849f6902187b91bf7e389 100644 (file)
@@ -39,8 +39,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 bool
 test_overlapping_ind_var_components()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
+  using ADHelper     = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType = typename ADHelper::ad_type;
 
   std::cout << "*** Test variables: Vector + Scalar (coupled), "
             << (AD::ADNumberTraits<ADNumberType>::is_taped == true ? "Taped" :
index f0c1d33428ce4f4c6f80c3efc2025fc0945b336f..1a55a4bc210a222abe3f23a8f43839436aef66ac 100644 (file)
@@ -38,8 +38,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 bool
 test_overlapping_ind_var_components()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
+  using ADHelper     = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType = typename ADHelper::ad_type;
 
   std::cout << "*** Test variables: Tensor + Vector (coupled), "
             << (AD::ADNumberTraits<ADNumberType>::is_taped == true ? "Taped" :
index 0f4ce829a09ed99d74bed0afbbcfbdce86e628fe..b36d7e8dd48046b261c2722dfb1c497a19e16328 100644 (file)
@@ -39,8 +39,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 bool
 test_incorrect_no_of_ind_vars()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
+  using ADHelper     = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType = typename ADHelper::ad_type;
 
   std::cout << "*** Test variables: Scalar + Scalar (coupled), "
             << (AD::ADNumberTraits<ADNumberType>::is_taped == true ? "Taped" :
index b0e9047951a4041470e1e8016e7c25abb723e09a..d65d70929f190fa1f2c0b66e590cfbfd67e3228a 100644 (file)
@@ -40,8 +40,8 @@ template <int dim, typename number_t, enum AD::NumberTypes ad_type_code>
 bool
 test_register_multiple_dep_vars()
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
+  using ADHelper     = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType = typename ADHelper::ad_type;
 
   std::cout << "*** Test variables: Scalar + Scalar (coupled), "
             << (AD::ADNumberTraits<ADNumberType>::is_taped == true ? "Taped" :
index bae7cd9d99e5997c9bef07c0125dc8dfa26d3623..bebbedf4578b39ea47ffc22e885aa44bf89d09b2 100644 (file)
@@ -92,9 +92,9 @@ test_scalar_scalar_coupled_one_run(const number_t     s1,
                                    const number_t     s2,
                                    const tape_index_t tape_no)
 {
-  typedef AD::ScalarFunction<dim, ad_type_code, number_t> ADHelper;
-  typedef typename ADHelper::ad_type                      ADNumberType;
-  typedef typename ADHelper::scalar_type                  ScalarNumberType;
+  using ADHelper         = AD::ScalarFunction<dim, ad_type_code, number_t>;
+  using ADNumberType     = typename ADHelper::ad_type;
+  using ScalarNumberType = typename ADHelper::scalar_type;
 
   std::cout
     //      << "*** Test variables: Scalar + Scalar (coupled), "
@@ -108,7 +108,7 @@ test_scalar_scalar_coupled_one_run(const number_t     s1,
   FullMatrix<ScalarNumberType> D2psi;
 
   // Function and its derivatives
-  typedef FunctionsTestScalarScalarCoupled<dim, ADNumberType> func_ad;
+  using func_ad = FunctionsTestScalarScalarCoupled<dim, ADNumberType>;
 
   // Setup the variable components and choose a value at which to
   // evaluate the tape
@@ -189,8 +189,8 @@ test_scalar_scalar_coupled_one_run(const number_t     s1,
   //      << "extracted Dpsi (s2): " << dpsi_ds2 << "\n";
 
   // Verify the result
-  typedef FunctionsTestScalarScalarCoupled<dim, ScalarNumberType> func;
-  static const ScalarNumberType                                   tol = 1.e-7;
+  using func = FunctionsTestScalarScalarCoupled<dim, ScalarNumberType>;
+  static const ScalarNumberType tol = 1.e-7;
   //  std::cout << "dpsi_ds1:            " << dpsi_ds1 << std::endl;
   //  std::cout << "func::dpsi_ds1(s1,s2): " << func::dpsi_ds1(s1,s2) <<
   //  std::endl; std::cout << "diff: " << std::abs(dpsi_ds1 -
index a76e730f0767aace3217528f8b3274ae83565e23..54d4045af02a748e95685fbbacb92900bbbe2066 100644 (file)
@@ -35,11 +35,11 @@ template <int dim,
 void
 test_tensor()
 {
-  typedef typename Differentiation::AD::NumberTraits<number_t,
-                                                     ad_number_enum>::ad_type
-                                      ad_number_t;
-  typedef Tensor<2, dim, ad_number_t> AD_Tensor;
-  typedef Tensor<2, dim, number_t>    NonAD_Tensor;
+  using ad_number_t =
+    typename Differentiation::AD::NumberTraits<number_t,
+                                               ad_number_enum>::ad_type;
+  using AD_Tensor    = Tensor<2, dim, ad_number_t>;
+  using NonAD_Tensor = Tensor<2, dim, number_t>;
 
   // Constructors
   NonAD_Tensor t1;
@@ -112,13 +112,13 @@ template <int dim,
 void
 test_symmetric_tensor()
 {
-  typedef typename Differentiation::AD::NumberTraits<number_t,
-                                                     ad_number_enum>::ad_type
-                                               ad_number_t;
-  typedef SymmetricTensor<2, dim, ad_number_t> AD_STensor;
-  typedef SymmetricTensor<4, dim, ad_number_t> AD_STensor4;
-  typedef SymmetricTensor<2, dim, number_t>    NonAD_STensor;
-  typedef SymmetricTensor<4, dim, number_t>    NonAD_STensor4;
+  using ad_number_t =
+    typename Differentiation::AD::NumberTraits<number_t,
+                                               ad_number_enum>::ad_type;
+  using AD_STensor     = SymmetricTensor<2, dim, ad_number_t>;
+  using AD_STensor4    = SymmetricTensor<4, dim, ad_number_t>;
+  using NonAD_STensor  = SymmetricTensor<2, dim, number_t>;
+  using NonAD_STensor4 = SymmetricTensor<4, dim, number_t>;
 
   // Constructors
   NonAD_STensor  t1;
index 12772c2b866f5afcede08946b89618004baeaced..a65b217446cb125c5c31d4a660ff2468e30f6147 100644 (file)
@@ -34,11 +34,11 @@ template <int dim,
 void
 test_tensor()
 {
-  typedef typename Differentiation::AD::NumberTraits<number_t,
-                                                     ad_number_enum>::ad_type
-                                      ad_number_t;
-  typedef Tensor<2, dim, ad_number_t> AD_Tensor;
-  typedef Tensor<2, dim, number_t>    NonAD_Tensor;
+  using ad_number_t =
+    typename Differentiation::AD::NumberTraits<number_t,
+                                               ad_number_enum>::ad_type;
+  using AD_Tensor    = Tensor<2, dim, ad_number_t>;
+  using NonAD_Tensor = Tensor<2, dim, number_t>;
 
   AD_Tensor adt1;
   for (unsigned int i = 0; i < NonAD_Tensor::n_independent_components; ++i)
@@ -55,13 +55,13 @@ template <int dim,
 void
 test_symmetric_tensor()
 {
-  typedef typename Differentiation::AD::NumberTraits<number_t,
-                                                     ad_number_enum>::ad_type
-                                               ad_number_t;
-  typedef SymmetricTensor<2, dim, ad_number_t> AD_STensor2;
-  typedef SymmetricTensor<4, dim, ad_number_t> AD_STensor4;
-  typedef SymmetricTensor<2, dim, number_t>    NonAD_STensor2;
-  typedef SymmetricTensor<4, dim, number_t>    NonAD_STensor4;
+  using ad_number_t =
+    typename Differentiation::AD::NumberTraits<number_t,
+                                               ad_number_enum>::ad_type;
+  using AD_STensor2    = SymmetricTensor<2, dim, ad_number_t>;
+  using AD_STensor4    = SymmetricTensor<4, dim, ad_number_t>;
+  using NonAD_STensor2 = SymmetricTensor<2, dim, number_t>;
+  using NonAD_STensor4 = SymmetricTensor<4, dim, number_t>;
 
   // Constructors
   AD_STensor2 adt1;
index 2414d381e0b02cf9e275d7ee644d58616409c887..5784d10b7153bc055b06ec9a63a7d3554b43e52b 100644 (file)
@@ -289,7 +289,7 @@ test()
                                             /*tolerance (global)*/ 0.0,
                                             /*reduce (w.r.t. initial)*/ 1.e-13);
 
-    typedef TrilinosWrappers::MPI::Vector  VectorType;
+    using VectorType = TrilinosWrappers::MPI::Vector;
     SolverGMRES<VectorType>                solver_c(inner_control_c);
     TrilinosWrappers::PreconditionIdentity preconditioner;
 
index b50ac4a9442b1b04bb1493385443667bcee79b7e..ccc7f45325aa57aeb2b4ae22fcf36ae03cc703bf 100644 (file)
@@ -137,7 +137,7 @@ test()
     // set up iterative inverse
     static ReductionControl inner_control_c(dof_handler.n_dofs(), 0.0, 1.e-13);
 
-    typedef LinearAlgebra::distributed::Vector<double> VectorType;
+    using VectorType = LinearAlgebra::distributed::Vector<double>;
     SolverCG<VectorType> solver_c(inner_control_c);
     PreconditionIdentity preconditioner;
     const auto           shift_and_invert =
index e08de962d31d8fc1dfdd898a08ce328697b3ed18..28de80add202626933502ff9306ff1e1a8511a13 100644 (file)
@@ -136,7 +136,7 @@ test()
     // set up iterative inverse
     static ReductionControl inner_control_c(dof_handler.n_dofs(), 0.0, 1.e-14);
 
-    typedef LinearAlgebra::distributed::Vector<double> VectorType;
+    using VectorType = LinearAlgebra::distributed::Vector<double>;
     SolverCG<VectorType> solver_c(inner_control_c);
     PreconditionIdentity preconditioner;
     const auto invert = inverse_operator(linear_operator<VectorType>(mass),
index e7f7b699b9d61e61571e97cb613a02e54d917828..c8567ed0856b3c30d7bc4c4a3e9df758087efb43 100644 (file)
@@ -137,7 +137,7 @@ test()
     // set up iterative inverse
     static ReductionControl inner_control_c(dof_handler.n_dofs(), 0.0, 1.e-14);
 
-    typedef LinearAlgebra::distributed::Vector<double> VectorType;
+    using VectorType = LinearAlgebra::distributed::Vector<double>;
     SolverCG<VectorType> solver_c(inner_control_c);
     PreconditionIdentity preconditioner;
     const auto invert = inverse_operator(linear_operator<VectorType>(mass),
index e2e8f591b3f167245b5b360a7dbe2d88943a92b6..3865dc3a060b9a0298c4c8626b86ca62d6bf935b 100644 (file)
@@ -277,7 +277,7 @@ test()
                                             /*tolerance (global)*/ 0.0,
                                             /*reduce (w.r.t. initial)*/ 1.e-13);
 
-    typedef TrilinosWrappers::MPI::Vector  VectorType;
+    using VectorType = TrilinosWrappers::MPI::Vector;
     SolverCG<VectorType>                   solver_c(inner_control_c);
     TrilinosWrappers::PreconditionIdentity preconditioner;
 
index 41d6a50bc0c7933f262c5bf875cf49c50cccaf2d..a1e3e695536c76c71e2487535a9741dd3c7ecbe0 100644 (file)
@@ -25,8 +25,8 @@
 void
 test()
 {
-  typedef AlignedVector<unsigned int> VEC;
-  VEC                                 a(4);
+  using VEC = AlignedVector<unsigned int>;
+  VEC a(4);
   deallog << "Constructor: ";
   for (unsigned int i = 0; i < a.size(); ++i)
     deallog << a[i] << " ";
index f6043b7041445c7e047bd333871891082c26ff57..64f6272e4484f81e71d848f7d00302fee7b93815 100644 (file)
@@ -21,8 +21,8 @@
 #include "../tests.h"
 
 
-typedef AlignedVector<unsigned int> VEC;
-typedef AlignedVector<VEC>          VECVEC;
+using VEC    = AlignedVector<unsigned int>;
+using VECVEC = AlignedVector<VEC>;
 void
 print_vec(VECVEC &v)
 {
@@ -39,8 +39,8 @@ print_vec(VECVEC &v)
 void
 test()
 {
-  typedef AlignedVector<unsigned int> VEC;
-  VEC                                 a(4);
+  using VEC = AlignedVector<unsigned int>;
+  VEC a(4);
   a[0] = 2;
   a[1] = 1;
   a[2] = 42;
index 42200a350fc5ecc03c5c2124502eca2517be664f..8a9cb19511f39f58693f977a5da4a1119204e6b0 100644 (file)
@@ -24,8 +24,8 @@
 void
 test()
 {
-  typedef AlignedVector<bool> VEC;
-  VEC                         a(4);
+  using VEC = AlignedVector<bool>;
+  VEC a(4);
   deallog << "Constructor: ";
   for (unsigned int i = 0; i < a.size(); ++i)
     deallog << a[i] << " ";
index 95f32babfc9cecd416293c84dca71897304327e5..777f542eb24be8e198bf79de4a9a4b4b0b7c8674 100644 (file)
@@ -24,7 +24,7 @@
 void
 test()
 {
-  typedef AlignedVector<unsigned int> VEC;
+  using VEC = AlignedVector<unsigned int>;
 
   VEC a(4, 2);
 
index 24f92e18cf696f38272485fea2aa6591ab94366c..091e076fee6044e6a9b4ad173239692fc2f82560 100644 (file)
@@ -25,7 +25,7 @@
 
 using namespace Polynomials;
 
-typedef std::vector<Polynomial<double>> PolVector;
+using PolVector = std::vector<Polynomial<double>>;
 
 
 void
index 775eecd823503809b0632a0b4534e2fedb80b7a7..f2de9cfbb603784a65a6a3edc0185d04c8de1d0a 100644 (file)
@@ -25,8 +25,8 @@
 // and we compute the first and second derivatives using
 // Sacado
 
-typedef typename Sacado::Fad::DFad<double>  Sdouble;
-typedef typename Sacado::Fad::DFad<Sdouble> SSdouble;
+using Sdouble  = typename Sacado::Fad::DFad<double>;
+using SSdouble = typename Sacado::Fad::DFad<Sdouble>;
 
 template <int dim, int spacedim>
 void
index 17b68b98c1d4f81cf095b99af342072f1f57e663..800c2d1bc14c34b90d7fef3ad00b2bcee5cfe993 100644 (file)
@@ -51,7 +51,7 @@ test(const unsigned int max_particles,
   auto my_proc = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
 
   // Test some fake structure, similar to particles
-  typedef typename std::pair<unsigned int, Point<dim>> particle;
+  using particle = typename std::pair<unsigned int, Point<dim>>;
 
 
   unsigned int          n_local_particles = random_index(max_particles);
index 294d5d6f3913725aee18c3a2a8a1ac0087d6c77e..61d68a8804b2ea7b802984474ab3d89281d99b59 100644 (file)
@@ -38,8 +38,8 @@ main()
   initlog();
   deallog << std::setprecision(3);
 
-  typedef Tensor<0, 1> T;
-  T                    t1(13.), t2(42);
+  using T = Tensor<0, 1>;
+  T t1(13.), t2(42);
 
   compare(T(), 0.);
   compare(T(13.), 13.);
index 0efa95f5cf0648d9fa352aeb1fd07400b689c01d..5e34c052bf8bab509e0e66a50cd8007f516d508b 100644 (file)
 void
 test()
 {
-  typedef VectorizedArray<double> vector_t;
-  const unsigned int              n_vectors = VectorizedArray<double>::size();
-  typedef AlignedVector<vector_t> VEC;
-  std::vector<double>             a_ref(4), b_ref;
-  VEC                             a(4);
+  using vector_t               = VectorizedArray<double>;
+  const unsigned int n_vectors = VectorizedArray<double>::size();
+  using VEC                    = AlignedVector<vector_t>;
+  std::vector<double> a_ref(4), b_ref;
+  VEC                 a(4);
   deallog << "Constructor: ";
   for (unsigned int i = 0; i < a.size(); ++i)
     for (unsigned int d = 0; d < n_vectors; ++d)
index 5f3a51066c899ec55b4e6cabada8360f99d3ff47..d626df1cd65b8da58ae4e3d695711c6a55cfd800 100644 (file)
@@ -73,7 +73,7 @@ DoFToolsEx::transfer(const DoFHandler<dim> &source_dof,
   InVector local_dofs(source_dof.get_fe().dofs_per_cell);
 
   // iterate over all active source cells
-  typedef typename DoFHandler<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
   cell_iterator cell = source_dof.begin_active(), endc = source_dof.end();
   for (; cell != endc; ++cell)
     {
index f5ccad2e92da2d6a43cf364bd6edffdac0a64744..74b808a96ea65a55c1bd49eb6008f41ed23bd7da 100644 (file)
@@ -35,28 +35,27 @@ main()
 {
   initlog();
 
-  typedef std::iterator_traits<TriaRawIterator<TriaAccessor<2, 2, 2>>>::
-    iterator_category tria_raw_iterator_category;
-  typedef std::iterator_traits<TriaIterator<TriaAccessor<2, 2, 2>>>::
-    iterator_category tria_iterator_category;
-  typedef std::iterator_traits<TriaActiveIterator<TriaAccessor<2, 2, 2>>>::
-    iterator_category tria_active_iterator_category;
-
-  typedef std::iterator_traits<
-    Particles::ParticleIterator<2>>::iterator_category particle_category;
-
-  typedef std::iterator_traits<IteratorRange<
-    Particles::ParticleIterator<2>>::IteratorOverIterators>::iterator_category
-    iterator_over_iterator_category;
-
-  typedef std::iterator_traits<
-    internal::BlockVectorIterators::Iterator<BlockVector<double>, false>>::
-    iterator_category block_vector_base_iterator_category;
-
-  typedef std::iterator_traits<IndexSet::IntervalIterator>::iterator_category
-    intervall_iterator_category;
-  typedef std::iterator_traits<IndexSet::ElementIterator>::iterator_category
-    element_iterator_category;
+  using tria_raw_iterator_category = std::iterator_traits<
+    TriaRawIterator<TriaAccessor<2, 2, 2>>>::iterator_category;
+  using tria_iterator_category = std::iterator_traits<
+    TriaIterator<TriaAccessor<2, 2, 2>>>::iterator_category;
+  using tria_active_iterator_category = std::iterator_traits<
+    TriaActiveIterator<TriaAccessor<2, 2, 2>>>::iterator_category;
+
+  using particle_category =
+    std::iterator_traits<Particles::ParticleIterator<2>>::iterator_category;
+
+  using iterator_over_iterator_category = std::iterator_traits<IteratorRange<
+    Particles::ParticleIterator<2>>::IteratorOverIterators>::iterator_category;
+
+  using block_vector_base_iterator_category = std::iterator_traits<
+    internal::BlockVectorIterators::Iterator<BlockVector<double>,
+                                             false>>::iterator_category;
+
+  using intervall_iterator_category =
+    std::iterator_traits<IndexSet::IntervalIterator>::iterator_category;
+  using element_iterator_category =
+    std::iterator_traits<IndexSet::ElementIterator>::iterator_category;
 
   deallog << "OK" << std::endl;
 }
index aa1e3f46888d1acedeff56b76badc0171d63ad08..ff7803dee73f737d88f9d146261947755f5415b9 100644 (file)
@@ -73,7 +73,7 @@ void
 MakeFlux<dim>::make_grid()
 {
   GridGenerator::hyper_cube(triangulation, -1, 1, true);
-  typedef typename dealii::Triangulation<dim>::cell_iterator CellIteratorTria;
+  using CellIteratorTria = typename dealii::Triangulation<dim>::cell_iterator;
   std::vector<dealii::GridTools::PeriodicFacePair<CellIteratorTria>>
                      periodic_faces;
   const unsigned int b_id1     = 2;
index f05986f3dbfde768a6a35a20bb6076c61fae32d8..e0b2ed0d90ccd4389fd5b8fd6d803affa8ea6833 100644 (file)
@@ -3263,10 +3263,10 @@ test()
   {
     const double tolerance = 1e-8;
 
-    typedef SolverBicgstab<> Solver;
-    SolverControl            solver_control(N, tolerance);
-    PrimitiveVectorMemory<>  vector_memory;
-    Solver                   solver(solver_control, vector_memory);
+    using Solver = SolverBicgstab<>;
+    SolverControl           solver_control(N, tolerance);
+    PrimitiveVectorMemory<> vector_memory;
+    Solver                  solver(solver_control, vector_memory);
 
     PreconditionSSOR<SparseMatrix<double>> preconditioner;
     preconditioner.initialize(sm, 1.2);
index 56c9c97f01ef2ef1dfd47534d462c8c2ea4230de..37e4c72ffb5bfc6644648fd869d6d6bdcb388279 100644 (file)
@@ -347,7 +347,7 @@ namespace LaplaceSolver
   void
   Solver<dim>::assemble_linear_system(LinearSystem &linear_system)
   {
-    typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
+    using active_cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
     const unsigned int n_threads = MultithreadInfo::n_threads();
     std::vector<std::pair<active_cell_iterator, active_cell_iterator>>
index b1463fe5300386ccc85661560fde29ffa91368ef..d602f94be984ee409cc45ea513c003752c8aa372 100644 (file)
@@ -429,7 +429,7 @@ namespace LaplaceSolver
   void
   Solver<dim>::assemble_linear_system(LinearSystem &linear_system)
   {
-    typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
+    using active_cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
     const unsigned int n_threads = MultithreadInfo::n_threads();
     std::vector<std::pair<active_cell_iterator, active_cell_iterator>>
@@ -1015,7 +1015,7 @@ namespace Data
   template <int dim>
   struct Exercise_2_3
   {
-    typedef Functions::ZeroFunction<dim> BoundaryValues;
+    using BoundaryValues = Functions::ZeroFunction<dim>;
 
     class RightHandSide : public Functions::ConstantFunction<dim>
     {
@@ -1354,10 +1354,10 @@ namespace LaplaceSolver
     void
     solve_dual_problem();
 
-    typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
+    using active_cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
-    typedef typename std::map<typename DoFHandler<dim>::face_iterator, double>
-      FaceIntegrals;
+    using FaceIntegrals =
+      typename std::map<typename DoFHandler<dim>::face_iterator, double>;
 
     struct CellData
     {
@@ -1901,8 +1901,8 @@ template <int dim>
 struct Framework
 {
 public:
-  typedef Evaluation::EvaluationBase<dim> Evaluator;
-  typedef std::list<Evaluator *>          EvaluatorList;
+  using Evaluator     = Evaluation::EvaluationBase<dim>;
+  using EvaluatorList = std::list<Evaluator *>;
 
 
   struct ProblemDescription
index d0566653cfa7f662f6a5bc5f8798052e4c5b682e..4dd9b93525435a4a1732dfa1db3c1d4abd98a3cc 100644 (file)
@@ -258,7 +258,7 @@ LaplaceProblem<dim>::solve()
   MGCoarseGridHouseholder<float, Vector<double>> mg_coarse;
   mg_coarse.initialize(coarse_matrix);
 
-  typedef PreconditionSOR<SparseMatrix<float>> RELAXATION;
+  using RELAXATION = PreconditionSOR<SparseMatrix<float>>;
   MGSmootherRelaxation<SparseMatrix<float>, RELAXATION, Vector<double>>
     mg_smoother;
 
index 80eb3dc4594ae7db5be236bce43b064a976eaade..0ef2a4d680b44607b69a2f6a08a810029564b75e 100644 (file)
@@ -154,7 +154,7 @@ void
 Step4<dim>::make_grid()
 {
   GridGenerator::hyper_cube(triangulation, -1, 1, true);
-  typedef typename dealii::Triangulation<dim>::cell_iterator CellIteratorTria;
+  using CellIteratorTria = typename dealii::Triangulation<dim>::cell_iterator;
   std::vector<dealii::GridTools::PeriodicFacePair<CellIteratorTria>>
                      periodic_faces;
   const unsigned int b_id1     = 2;
index 5ea1a127d91d61b1707d92a2ef5c531db1ed10f2..e77c96f85ca018165e4529f0e652fe3da2b91d93 100644 (file)
@@ -154,7 +154,7 @@ void
 Step4<dim>::make_grid()
 {
   GridGenerator::hyper_cube(triangulation, -1, 1, true);
-  typedef typename dealii::Triangulation<dim>::cell_iterator CellIteratorTria;
+  using CellIteratorTria = typename dealii::Triangulation<dim>::cell_iterator;
   std::vector<dealii::GridTools::PeriodicFacePair<CellIteratorTria>>
                      periodic_faces;
   const unsigned int b_id1     = 2;
index f919c63b622913092286f33de3528a136f93a8bb..69d6a1000cc6e196e4d637f46f3789a4aa552624 100644 (file)
@@ -62,7 +62,7 @@ template <int dim, int fe_degree, typename VectorType>
 void
 test()
 {
-  typedef double Number;
+  using Number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index a5523ce6eed989f047e58805ccfde8cf67c3420e..cd6cd531e7b08eb1faf71f2d9b4e0ed0d45187e6 100644 (file)
@@ -54,7 +54,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double Number;
+  using Number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index f2831c13275e4b44712e082d694d8e9f7c95e8ea..55734b1d297c1b4f67029bba571a6497339a098a 100644 (file)
@@ -56,7 +56,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double Number;
+  using Number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index e45cbc41f97bac25d9be44ba5d09dc974d83fd64..cf7f617e04f81e85a79749cbaf0c9e8fea9fd429 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double Number;
+  using Number = double;
 
   parallel::shared::Triangulation<dim> tria(
     MPI_COMM_WORLD,
index 475270fc723c705f185f9269f3227c53befc4038..86bc853f093610ee599b8b534e041120f2fdfb20 100644 (file)
@@ -48,7 +48,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double Number;
+  using Number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index f0afe26dd95f1bc345948b8929c91b676c50e4be..10e2f204d25b948e43d48497eceeae6ccf0b8d5c 100644 (file)
@@ -40,7 +40,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double Number;
+  using Number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 3aaee7147b796a18a75f0ca6b2c8efa63df6a5c7..4dc32b4cccce75e85f30d91604c61971114b5db2 100644 (file)
@@ -55,7 +55,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double Number;
+  using Number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index aa73d51de3d4378f4fcb89e8e1f4d8fad4040493..d10c2115f841171383d7b7b2a2e8b1fc1cd50f38 100644 (file)
@@ -55,7 +55,7 @@ template <int dim>
 class TriaTest
 {
 private:
-  typedef typename parallel::distributed::Triangulation<dim> TypeTria;
+  using TypeTria = typename parallel::distributed::Triangulation<dim>;
 
 public:
   TriaTest(const typename dealii::Triangulation<dim>::MeshSmoothing
index 594a181881f789b1e60b4860177c708096b79bb6..887570e464019d1e1d458516caca1df96d58808f 100644 (file)
@@ -55,7 +55,7 @@ template <int dim>
 class TriaTest
 {
 private:
-  typedef typename parallel::distributed::Triangulation<dim> TypeTria;
+  using TypeTria = typename parallel::distributed::Triangulation<dim>;
 
 public:
   TriaTest(const typename dealii::Triangulation<dim>::MeshSmoothing
index 22fe413e1d67aa556dd6a49684c4b9967a7384d4..4289128bef7c5ed71e3f92c91e8f777a87e9e52c 100644 (file)
@@ -43,7 +43,7 @@ test()
   std::set<std::string> input, output;
 
 
-  typedef double       DT;
+  using DT = double;
   std::map<CellId, DT> map;
   DT                   counter = 0.0;
 
@@ -70,9 +70,8 @@ test()
           }
       }
 
-  typedef
-    typename parallel::distributed::Triangulation<dim>::active_cell_iterator
-      cell_iterator;
+  using cell_iterator =
+    typename parallel::distributed::Triangulation<dim>::active_cell_iterator;
   GridTools::
     exchange_cell_data_to_ghosts<DT, parallel::distributed::Triangulation<dim>>(
       tria,
index c0e61d6555272a5690d85974d33e8bd0aa3924c6..6c804b9f5c2d61c733a8adc089b82f00d4b5776b 100644 (file)
@@ -51,10 +51,10 @@ test()
 
   std::set<std::string> input, output;
 
-  typedef typename DoFHandler<dim>::active_cell_iterator cell_iterator;
-  typedef short                                          DT;
-  std::map<CellId, DT>                                   map;
-  short                                                  counter = 0;
+  using cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
+  using DT            = short;
+  std::map<CellId, DT> map;
+  short                counter = 0;
 
   std::map<unsigned int, std::set<dealii::types::subdomain_id>>
     vertices_with_ghost_neighbors =
index f801858bee7bc4162a7397c488dc9c915c34fd62..d71d4b4abcda845542e354a553043c676bb6cebe 100644 (file)
@@ -48,9 +48,9 @@ test()
 
   std::set<std::string> input, output;
 
-  typedef typename parallel::shared::Triangulation<dim>::active_cell_iterator
-                       cell_iterator;
-  typedef double       DT;
+  using cell_iterator =
+    typename parallel::shared::Triangulation<dim>::active_cell_iterator;
+  using DT = double;
   std::map<CellId, DT> map;
   DT                   counter = 0.0;
 
index 7cab39e2ae8a5283e65e195d7b7bc8c4ced06932..9bc159392dfc64238d487b5a17913eb512e45585 100644 (file)
@@ -47,10 +47,9 @@ test()
   std::map<CellId, std::string> input;
   std::set<std::string>         output;
 
-  typedef
-    typename parallel::distributed::Triangulation<dim>::active_cell_iterator
-                        cell_iterator;
-  typedef double        DT;
+  using cell_iterator =
+    typename parallel::distributed::Triangulation<dim>::active_cell_iterator;
+  using DT = double;
   std::map<CellId, int> map;
   int                   counter = 0;
 
index e92488351f6475fdd6a62dac0e55eb98fcf08513..edc4d1b21f0a712dd04d7974c82177e004117de2 100644 (file)
@@ -89,7 +89,7 @@ test(unsigned n_refinements)
   InterGridMap<DoFHandler<dim>> grid_1_to_2_map;
   grid_1_to_2_map.make_mapping(dof_handler1, dof_handler2);
 
-  typedef std::vector<std::map<types::global_dof_index, float>> TransferRep;
+  using TransferRep = std::vector<std::map<types::global_dof_index, float>>;
   TransferRep transfer_representation;
   DoFTools::compute_intergrid_transfer_representation(
     dof_handler1, 0, dof_handler2, 0, grid_1_to_2_map, transfer_representation);
index 123fcac172ab4bd844e9839efd4ba85ea495700f..99a03d853a5ad5944e6e28a59d5472f108c77c6d 100644 (file)
@@ -437,7 +437,7 @@ namespace LaplaceSolver
   void
   Solver<dim>::assemble_linear_system(LinearSystem &linear_system)
   {
-    typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
+    using active_cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
     const unsigned int n_threads = MultithreadInfo::n_threads();
     std::vector<std::pair<active_cell_iterator, active_cell_iterator>>
@@ -1029,7 +1029,7 @@ namespace Data
   template <int dim>
   struct Exercise_2_3
   {
-    typedef Functions::ZeroFunction<dim> BoundaryValues;
+    using BoundaryValues = Functions::ZeroFunction<dim>;
 
     class RightHandSide : public Functions::ConstantFunction<dim>
     {
@@ -1371,10 +1371,10 @@ namespace LaplaceSolver
     void
     solve_dual_problem();
 
-    typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
+    using active_cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
-    typedef typename std::map<typename DoFHandler<dim>::face_iterator, double>
-      FaceIntegrals;
+    using FaceIntegrals =
+      typename std::map<typename DoFHandler<dim>::face_iterator, double>;
 
     struct CellData
     {
@@ -1927,8 +1927,8 @@ template <int dim>
 struct Framework
 {
 public:
-  typedef Evaluation::EvaluationBase<dim> Evaluator;
-  typedef std::list<Evaluator *>          EvaluatorList;
+  using Evaluator     = Evaluation::EvaluationBase<dim>;
+  using EvaluatorList = std::list<Evaluator *>;
 
 
   struct ProblemDescription
index 7db630be930b21aa377d0b2d3d4158d05865b22f..81ab9fb7af23963ab7734ade26184dc926cf4151 100644 (file)
@@ -71,9 +71,8 @@ test()
 
   // Construct vector of predicates for 2 and 3 dimensions
   Assert(dim == 2 || dim == 3, ExcDimensionMismatch2(dim, 2, 3));
-  typedef std::function<bool(
-    const typename Triangulation<dim>::active_cell_iterator &)>
-                                  predicate_function;
+  using predicate_function = std::function<bool(
+    const typename Triangulation<dim>::active_cell_iterator &)>;
   std::vector<predicate_function> predicates;
   predicates.resize(5);
   if (dim == 2)
index 2b9e62a799a59b67250a9ecd4726c0bfcc6fdd8b..8b98c87b8e3a4869b8d0c0ddba730807f444b46e 100644 (file)
@@ -67,13 +67,13 @@ namespace Step22
   template <>
   struct InnerPreconditioner<2>
   {
-    typedef SparseDirectUMFPACK type;
+    using type = SparseDirectUMFPACK;
   };
 
   template <>
   struct InnerPreconditioner<3>
   {
-    typedef SparseILU<double> type;
+    using type = SparseILU<double>;
   };
 
   template <int dim>
index ecd799eb0b2811b977cffaeceb21376cb6d4a98e..614b4ad7e15a369eab81385ece3655119eba8004 100644 (file)
@@ -124,8 +124,8 @@ test_interpolation()
   Quadrature<2> quadrature(fe.get_generalized_support_points());
   FEValues<2>   fev(fe, quadrature, update_values | update_JxW_values);
 
-  typedef DoFHandler<2>::cell_iterator cell_it;
-  cell_it                              cell = dofh.begin_active();
+  using cell_it = DoFHandler<2>::cell_iterator;
+  cell_it cell  = dofh.begin_active();
   for (; cell != dofh.end(); ++cell)
     {
       fev.reinit(cell);
index e05ebb357a1508e1d5cf3d759418516aab949fbf..150c2d8a5c5258f49106c2443121fbb71def43c5 100644 (file)
@@ -54,23 +54,23 @@ test_view(const Vector<double> &            solution,
           const FEValuesExtractors::Scalar &extractor,
           const std::vector<NumberType> &   local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    value_type;
-  typedef typename ProductType<typename View::gradient_type, NumberType>::type
-    gradient_type;
-  typedef typename ProductType<typename View::hessian_type, NumberType>::type
-    hessian_type;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    laplacian_type;
-  typedef
-    typename ProductType<typename View::third_derivative_type, NumberType>::type
-      third_derivative_type;
+  using OutputType = typename View::template OutputType<NumberType>;
+  using value_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using gradient_type =
+    typename ProductType<typename View::gradient_type, NumberType>::type;
+  using hessian_type =
+    typename ProductType<typename View::hessian_type, NumberType>::type;
+  using laplacian_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using third_derivative_type =
+    typename ProductType<typename View::third_derivative_type,
+                         NumberType>::type;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
@@ -140,29 +140,30 @@ test_view(const Vector<double> &            solution,
           const FEValuesExtractors::Vector &extractor,
           const std::vector<NumberType> &   local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    value_type;
-  typedef typename ProductType<typename View::gradient_type, NumberType>::type
-                                                 gradient_type;
-  typedef typename ProductType<typename View::symmetric_gradient_type,
-                               NumberType>::type symmetric_gradient_type;
-  typedef typename ProductType<typename View::divergence_type, NumberType>::type
-    divergence_type;
-  typedef
-    typename ProductType<typename View::curl_type, NumberType>::type curl_type;
-  typedef typename ProductType<typename View::hessian_type, NumberType>::type
-    hessian_type;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    laplacian_type;
-  typedef
-    typename ProductType<typename View::third_derivative_type, NumberType>::type
-      third_derivative_type;
+  using OutputType = typename View::template OutputType<NumberType>;
+  using value_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using gradient_type =
+    typename ProductType<typename View::gradient_type, NumberType>::type;
+  using symmetric_gradient_type =
+    typename ProductType<typename View::symmetric_gradient_type,
+                         NumberType>::type;
+  using divergence_type =
+    typename ProductType<typename View::divergence_type, NumberType>::type;
+  using curl_type =
+    typename ProductType<typename View::curl_type, NumberType>::type;
+  using hessian_type =
+    typename ProductType<typename View::hessian_type, NumberType>::type;
+  using laplacian_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using third_derivative_type =
+    typename ProductType<typename View::third_derivative_type,
+                         NumberType>::type;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
@@ -269,16 +270,16 @@ test_view(const Vector<double> &                        solution,
           const FEValuesExtractors::SymmetricTensor<2> &extractor,
           const std::vector<NumberType> &               local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    value_type;
-  typedef typename ProductType<typename View::divergence_type, NumberType>::type
-    divergence_type;
+  using OutputType = typename View::template OutputType<NumberType>;
+  using value_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using divergence_type =
+    typename ProductType<typename View::divergence_type, NumberType>::type;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
@@ -315,18 +316,18 @@ test_view(const Vector<double> &               solution,
           const FEValuesExtractors::Tensor<2> &extractor,
           const std::vector<NumberType> &      local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    value_type;
-  typedef typename ProductType<typename View::gradient_type, NumberType>::type
-    gradient_type;
-  typedef typename ProductType<typename View::divergence_type, NumberType>::type
-    divergence_type;
+  using OutputType = typename View::template OutputType<NumberType>;
+  using value_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using gradient_type =
+    typename ProductType<typename View::gradient_type, NumberType>::type;
+  using divergence_type =
+    typename ProductType<typename View::divergence_type, NumberType>::type;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
index 708ac63ffa61aed4d80d5fda9aa6a01c40620390..5045af2f7986af5fa36f9c64cf5cbd691b8c4b96 100644 (file)
@@ -60,12 +60,12 @@ test_view(const Vector<double> &            solution,
           const FEValuesExtractors::Scalar &extractor,
           const std::vector<NumberType> &   local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
+  using OutputType = typename View::template OutputType<NumberType>;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
@@ -103,12 +103,12 @@ test_view(const Vector<double> &            solution,
           const FEValuesExtractors::Vector &extractor,
           const std::vector<NumberType> &   local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
+  using OutputType = typename View::template OutputType<NumberType>;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
@@ -162,16 +162,16 @@ test_view(const Vector<double> &                        solution,
           const FEValuesExtractors::SymmetricTensor<2> &extractor,
           const std::vector<NumberType> &               local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    value_type;
-  typedef typename ProductType<typename View::divergence_type, NumberType>::type
-    divergence_type;
+  using OutputType = typename View::template OutputType<NumberType>;
+  using value_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using divergence_type =
+    typename ProductType<typename View::divergence_type, NumberType>::type;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
@@ -193,18 +193,18 @@ test_view(const Vector<double> &               solution,
           const FEValuesExtractors::Tensor<2> &extractor,
           const std::vector<NumberType> &      local_dof_values)
 {
-  typedef typename std::remove_reference<typename std::remove_const<decltype(
-    fe_values[extractor])>::type>::type View;
-  const View &                          fe_values_view = fe_values[extractor];
+  using View = typename std::remove_reference<
+    typename std::remove_const<decltype(fe_values[extractor])>::type>::type;
+  const View &fe_values_view = fe_values[extractor];
 
   // Typedefs
-  typedef typename View::template OutputType<NumberType> OutputType;
-  typedef typename ProductType<typename View::value_type, NumberType>::type
-    value_type;
-  typedef typename ProductType<typename View::gradient_type, NumberType>::type
-    gradient_type;
-  typedef typename ProductType<typename View::divergence_type, NumberType>::type
-    divergence_type;
+  using OutputType = typename View::template OutputType<NumberType>;
+  using value_type =
+    typename ProductType<typename View::value_type, NumberType>::type;
+  using gradient_type =
+    typename ProductType<typename View::gradient_type, NumberType>::type;
+  using divergence_type =
+    typename ProductType<typename View::divergence_type, NumberType>::type;
 
   // Values
   std::vector<typename OutputType::value_type> qp_values_local(n_q_points);
index ce696f5f8bde9b158f83ba5da71907be786b4174..d235ee4ff141451ac44c7de95162d011d640943c 100644 (file)
@@ -265,8 +265,8 @@ namespace Step12
   void
   AdvectionProblem<dim>::assemble_system()
   {
-    typedef decltype(dof_handler.begin_active()) Iterator;
-    BoundaryValues<dim>                          boundary_function;
+    using Iterator = decltype(dof_handler.begin_active());
+    BoundaryValues<dim> boundary_function;
 
     auto cell_worker = [&](const Iterator &  cell,
                            ScratchData<dim> &scratch_data,
index 4ebc44a532154bbbaa2c06425675e60a8fb1abeb..70378ed135d90b00b51663d5cca83d9df5102c72 100644 (file)
@@ -146,7 +146,7 @@ template <int dim>
 void
 test_LA_Trilinos()
 {
-  typedef LA_Trilinos LA;
+  using LA = LA_Trilinos;
 
   unsigned int myid    = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   unsigned int numproc = Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
index 6bf10893f20603ee913a481dd0a9e002b8852d42..419dc8b47c0c68c1d0d141a0e8dbef4d9874a649 100644 (file)
@@ -102,7 +102,7 @@ test()
   deallog << "relevant: ";
   locally_relevant_dofs.print(deallog);
 
-  typedef typename LA::MPI::BlockSparseMatrix::value_type number;
+  using number = typename LA::MPI::BlockSparseMatrix::value_type;
 
   AffineConstraints<number> constraints(locally_relevant_dofs);
   constraints.close();
@@ -160,9 +160,9 @@ template <int dim>
 void
 test_alt()
 {
-  typedef LA_Trilinos LA;
-  unsigned int        myid = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
-  unsigned int        numproc = Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
+  using LA             = LA_Trilinos;
+  unsigned int myid    = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
+  unsigned int numproc = Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
 
   if (myid == 0)
     deallog << "numproc=" << numproc << std::endl;
index 21b3ceb4c2a9a26ab5b1952271c77663f53b14da..811a54730c035c77076ab83ad071376d859363cb 100644 (file)
@@ -21,10 +21,10 @@ public:
   class MPI
   {
   public:
-    typedef LinearAlgebraPETSc::MPI::Vector            Vector;
-    typedef LinearAlgebraPETSc::MPI::SparseMatrix      SparseMatrix;
-    typedef LinearAlgebraPETSc::MPI::BlockVector       BlockVector;
-    typedef LinearAlgebraPETSc::MPI::BlockSparseMatrix BlockSparseMatrix;
+    using Vector            = LinearAlgebraPETSc::MPI::Vector;
+    using SparseMatrix      = LinearAlgebraPETSc::MPI::SparseMatrix;
+    using BlockVector       = LinearAlgebraPETSc::MPI::BlockVector;
+    using BlockSparseMatrix = LinearAlgebraPETSc::MPI::BlockSparseMatrix;
   };
 };
 
@@ -34,10 +34,10 @@ public:
   class MPI
   {
   public:
-    typedef LinearAlgebraTrilinos::MPI::Vector            Vector;
-    typedef LinearAlgebraTrilinos::MPI::SparseMatrix      SparseMatrix;
-    typedef LinearAlgebraTrilinos::MPI::BlockVector       BlockVector;
-    typedef LinearAlgebraTrilinos::MPI::BlockSparseMatrix BlockSparseMatrix;
+    using Vector            = LinearAlgebraTrilinos::MPI::Vector;
+    using SparseMatrix      = LinearAlgebraTrilinos::MPI::SparseMatrix;
+    using BlockVector       = LinearAlgebraTrilinos::MPI::BlockVector;
+    using BlockSparseMatrix = LinearAlgebraTrilinos::MPI::BlockSparseMatrix;
   };
 };
 
index 76a48edf1f2505d19868f6c8cb2e6ae0cd494b2f..f79c4c9ddc6bb7c372180c3faefeb80b1e3098ff 100644 (file)
@@ -107,7 +107,7 @@ template <int dim>
 void
 test_trilinos_alternative()
 {
-  typedef LA_Trilinos LA;
+  using LA = LA_Trilinos;
 
   unsigned int myid    = Utilities::MPI::this_mpi_process(MPI_COMM_WORLD);
   unsigned int numproc = Utilities::MPI::n_mpi_processes(MPI_COMM_WORLD);
index 8ffcc5bc6cbdb4b254562fd5e681599405fd1995..0bac2bea9533f237cc82294cd37532ff259eaa9b 100644 (file)
@@ -37,7 +37,7 @@ DeclException2(ExcNumberMismatch,
 
 
 
-typedef Triangulation<2>::active_cell_iterator active_cell_iterator;
+using active_cell_iterator = Triangulation<2>::active_cell_iterator;
 
 template <typename Iterator>
 bool
@@ -154,7 +154,7 @@ test()
   // check 4: and yet another possibility
   if (true)
     {
-      typedef FilteredIterator<active_cell_iterator> FI;
+      using FI = FilteredIterator<active_cell_iterator>;
 
       bool (*predicate)(const active_cell_iterator, const unsigned int) =
         &level_equal_to<active_cell_iterator>;
@@ -182,9 +182,9 @@ test()
   // id
   if (true)
     {
-      typedef FilteredIterator<active_cell_iterator> FI;
-      const IteratorFilters::SubdomainEqualTo        predicate(1);
-      FI                                             cell(predicate);
+      using FI = FilteredIterator<active_cell_iterator>;
+      const IteratorFilters::SubdomainEqualTo predicate(1);
+      FI                                      cell(predicate);
       cell.set_to_next_positive(tria.begin_active());
       active_cell_iterator endc(tria.end());
       active_cell_iterator cell1 = tria.begin_active();
index 4e8186b385ec62dd69b0684524d4216256df36a2..24c93a4da99ee2116f68ae9f312a389931020f43 100644 (file)
@@ -37,7 +37,7 @@ DeclException2(ExcNumberMismatch,
 
 
 
-typedef Triangulation<2>::active_cell_iterator active_cell_iterator;
+using active_cell_iterator = Triangulation<2>::active_cell_iterator;
 
 template <typename Iterator>
 bool
@@ -156,7 +156,7 @@ test()
   // check 4: and yet another possibility
   if (true)
     {
-      typedef FilteredIterator<active_cell_iterator> FI;
+      using FI = FilteredIterator<active_cell_iterator>;
 
       bool (*predicate)(const active_cell_iterator, const unsigned int) =
         &level_equal_to<active_cell_iterator>;
@@ -184,9 +184,9 @@ test()
   // id
   if (true)
     {
-      typedef FilteredIterator<active_cell_iterator> FI;
-      const IteratorFilters::SubdomainEqualTo        predicate(1);
-      FI                                             cell(predicate);
+      using FI = FilteredIterator<active_cell_iterator>;
+      const IteratorFilters::SubdomainEqualTo predicate(1);
+      FI                                      cell(predicate);
       cell.set_to_next_positive(tria.begin_active());
       active_cell_iterator endc(tria.end());
       active_cell_iterator cell1 = tria.begin_active();
index d63905e58e4e05a879c72c38f61ce4658ac273f3..e6c522a490e89c7ef71a6a367010b889f9c53435 100644 (file)
@@ -37,7 +37,7 @@ DeclException2(ExcNumberMismatch,
 
 
 
-typedef Triangulation<2>::active_cell_iterator active_cell_iterator;
+using active_cell_iterator = Triangulation<2>::active_cell_iterator;
 
 template <typename Iterator>
 bool
index f8897b246cb97f5ec14ee8926af785ab32932041..1990b8148416fa2a36de56459871bded06742415 100644 (file)
@@ -26,7 +26,7 @@
 
 #include "../tests.h"
 
-typedef Triangulation<2>::active_cell_iterator active_cell_iterator;
+using active_cell_iterator = Triangulation<2>::active_cell_iterator;
 
 void
 test()
index 8017febffde0b17e600695bcd62782e51b7e77be..a280bb8ef4edfad905e5d701779ea5b2f02c04dd 100644 (file)
@@ -50,9 +50,9 @@ test()
   tria[1].last_active()->set_refine_flag();
   tria[1].execute_coarsening_and_refinement();
 
-  typedef std::list<std::pair<typename Triangulation<dim>::cell_iterator,
-                              typename Triangulation<dim>::cell_iterator>>
-    CellList;
+  using CellList =
+    std::list<std::pair<typename Triangulation<dim>::cell_iterator,
+                        typename Triangulation<dim>::cell_iterator>>;
 
   const CellList cell_list =
     GridTools::get_finest_common_cells(tria[0], tria[1]);
index 5c1d0939aef8d9e17eb2471e4d67261526c2149e..885bec866bf158fa1f19e82dfd2b53cbd6baf540 100644 (file)
@@ -53,9 +53,9 @@ test()
   DoFHandler<dim> dh0(tria[0]);
   DoFHandler<dim> dh1(tria[1]);
 
-  typedef std::list<std::pair<typename DoFHandler<dim>::cell_iterator,
-                              typename DoFHandler<dim>::cell_iterator>>
-    CellList;
+  using CellList =
+    std::list<std::pair<typename DoFHandler<dim>::cell_iterator,
+                        typename DoFHandler<dim>::cell_iterator>>;
 
   const CellList cell_list = GridTools::get_finest_common_cells(dh0, dh1);
   for (typename CellList::const_iterator cell_pair = cell_list.begin();
index 5c1d0939aef8d9e17eb2471e4d67261526c2149e..885bec866bf158fa1f19e82dfd2b53cbd6baf540 100644 (file)
@@ -53,9 +53,9 @@ test()
   DoFHandler<dim> dh0(tria[0]);
   DoFHandler<dim> dh1(tria[1]);
 
-  typedef std::list<std::pair<typename DoFHandler<dim>::cell_iterator,
-                              typename DoFHandler<dim>::cell_iterator>>
-    CellList;
+  using CellList =
+    std::list<std::pair<typename DoFHandler<dim>::cell_iterator,
+                        typename DoFHandler<dim>::cell_iterator>>;
 
   const CellList cell_list = GridTools::get_finest_common_cells(dh0, dh1);
   for (typename CellList::const_iterator cell_pair = cell_list.begin();
index fb750f37ad33ed74c5bc199061e1a0549643c1c4..a06bca88a86205d7b3b15ce00ccaaed01a88a52d 100644 (file)
@@ -79,9 +79,9 @@ test()
     }
 #endif
 
-  typedef std::list<std::pair<typename Triangulation<dim>::cell_iterator,
-                              typename Triangulation<dim>::cell_iterator>>
-    CellList;
+  using CellList =
+    std::list<std::pair<typename Triangulation<dim>::cell_iterator,
+                        typename Triangulation<dim>::cell_iterator>>;
 
   deallog << "number of locally owned cells in tria 0 and tria 1: "
           << tria_0.n_active_cells() << ' ' << tria_1.n_active_cells()
index 95a22adb6889be13f51ece8055f3a9f3315143ff..a8046cc05f957b4706009197d0eafc7801c683a2 100644 (file)
@@ -187,9 +187,9 @@ main()
 
   generate_grid(triangulation2);
 
-  typedef Triangulation<2>::cell_iterator                         CellIterator2;
-  typedef std::vector<GridTools::PeriodicFacePair<CellIterator2>> FaceVector2;
-  FaceVector2                                                     test2;
+  using CellIterator2 = Triangulation<2>::cell_iterator;
+  using FaceVector2   = std::vector<GridTools::PeriodicFacePair<CellIterator2>>;
+  FaceVector2 test2;
   GridTools::collect_periodic_faces(
     triangulation2, 42, 1, test2, dealii::Tensor<1, 2>());
 
@@ -206,9 +206,9 @@ main()
 
   generate_grid(triangulation3);
 
-  typedef Triangulation<3>::cell_iterator                         CellIterator3;
-  typedef std::vector<GridTools::PeriodicFacePair<CellIterator3>> FaceVector3;
-  FaceVector3                                                     test3;
+  using CellIterator3 = Triangulation<3>::cell_iterator;
+  using FaceVector3   = std::vector<GridTools::PeriodicFacePair<CellIterator3>>;
+  FaceVector3 test3;
   GridTools::collect_periodic_faces(
     triangulation3, 42, 2, test3, dealii::Tensor<1, 3>());
 
index 9ccb26111530da152b9b28eb3e972d9d46a55fd2..f489b0d54d0dc8e8b2e1e92a229744e52b069cdb 100644 (file)
@@ -201,9 +201,9 @@ main()
 
       generate_grid(triangulation, i);
 
-      typedef Triangulation<2>::cell_iterator CellIterator;
-      typedef std::vector<GridTools::PeriodicFacePair<CellIterator>> FaceVector;
-      FaceVector                                                     test;
+      using CellIterator = Triangulation<2>::cell_iterator;
+      using FaceVector = std::vector<GridTools::PeriodicFacePair<CellIterator>>;
+      FaceVector test;
       GridTools::collect_periodic_faces(
         triangulation, 42, 43, 1, test, dealii::Tensor<1, 2>());
 
@@ -224,9 +224,9 @@ main()
 
       generate_grid(triangulation, i);
 
-      typedef Triangulation<3>::cell_iterator CellIterator;
-      typedef std::vector<GridTools::PeriodicFacePair<CellIterator>> FaceVector;
-      FaceVector                                                     test;
+      using CellIterator = Triangulation<3>::cell_iterator;
+      using FaceVector = std::vector<GridTools::PeriodicFacePair<CellIterator>>;
+      FaceVector test;
       GridTools::collect_periodic_faces(
         triangulation, 42, 43, 2, test, dealii::Tensor<1, 3>());
 
index ba788cba70a36c5ce6bc2225c5430b99c88d9a8f..ee1d06414d6386576cf2de9332404247ef6c9350 100644 (file)
@@ -60,7 +60,7 @@ test()
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  typedef typename Triangulation<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = tria.begin_active(), endc = tria.end();
index 1a0265f987c6401a956d9d369c0a64dcccf924f9..3f9b886c2113db7b336e3b8f049aec86fdce1208 100644 (file)
@@ -90,7 +90,7 @@ test()
   GridGenerator::subdivided_hyper_rectangle(
     tria, step_sizes, bottom_left, upper_right, true);
 
-  typedef typename Triangulation<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = tria.begin_active(), endc = tria.end();
index 200b93772f5687f44422af3a224185c45df9ccd1..417f0728b97b2640ef49dd2b9a7f0ce2ea39c898 100644 (file)
@@ -39,7 +39,7 @@ test()
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  typedef typename Triangulation<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = tria.begin_active(), endc = tria.end();
index 9bd048a3fca7dc35be96d764eed4d7332c78db28..d566b7ffb65d73e6f585e985103e20b67eb9d19a 100644 (file)
@@ -43,7 +43,7 @@ test()
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  typedef typename Triangulation<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = tria.begin_active(), endc = tria.end();
index 46740b47ee2110f31da898038673dd935a5a8bbe..4af8ad614e6fc993d6431b693cc9aa1dbcc9b614 100644 (file)
@@ -56,8 +56,8 @@ test_hypercube(unsigned int ref, unsigned int max_bbox)
   GridGenerator::hyper_cube(tria);
   tria.refine_global(4);
 
-  typedef typename parallel::distributed::Triangulation<dim, spacedim>::
-    active_cell_iterator cell_iterator;
+  using cell_iterator = typename parallel::distributed::
+    Triangulation<dim, spacedim>::active_cell_iterator;
 
   std::function<bool(const cell_iterator &)> predicate =
     pred_locally_owned<dim, spacedim>;
index 22d7946cd2c3fc0720a4cdf89c35194a075e5381..c8f9f7e76b475b4dcb6df31c317157502f63393f 100644 (file)
@@ -55,7 +55,7 @@ test()
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  typedef typename Triangulation<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = tria.begin_active(), endc = tria.end();
index 4253584e8e1f90b38e1c39f099b234ceaa127fca..7f9c2779f0c9c1d04bca17922718e766b63c3f1e 100644 (file)
@@ -49,7 +49,7 @@ test()
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  typedef typename Triangulation<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = tria.begin_active(), endc = tria.end();
index 3a10d73023e96fbfddd917c02cba6a408351c269..eeca99e5a7ab500cf10d469f66fed3c5c47a7dbb 100644 (file)
@@ -49,7 +49,7 @@ test()
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  typedef typename Triangulation<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = tria.begin_active(), endc = tria.end();
index cb838440d51cb4bb6509a9861e09268cd41eb579..2988635f243436716f83b2acd4e5f1ea59eaf4c1 100644 (file)
@@ -85,7 +85,7 @@ test()
   tria.refine_global(2);
   DoFHandler<dim> dof_handler(tria);
 
-  typedef typename DoFHandler<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = dof_handler.begin_active(), endc = dof_handler.end();
index 08258d8a4b733feb1c71886be1ccc68992ff5d5a..4c3ef6f19178f8d748c1b368048c963ed41393e8 100644 (file)
@@ -85,7 +85,7 @@ test()
   tria.refine_global(2);
   DoFHandler<dim> dof_handler(tria);
 
-  typedef typename DoFHandler<dim>::active_cell_iterator cell_iterator;
+  using cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   cell_iterator cell = dof_handler.begin_active(), endc = dof_handler.end();
index 93770ffde851ae48efdf1602845a1a22c493fe4f..a920d512da710ee303f25a459175689e1d4738cb 100644 (file)
@@ -37,9 +37,8 @@ test()
   GridGenerator::hyper_cube(tria);
   tria.refine_global(2);
 
-  typedef
-    typename parallel::distributed::Triangulation<dim>::active_cell_iterator
-      cell_iterator;
+  using cell_iterator =
+    typename parallel::distributed::Triangulation<dim>::active_cell_iterator;
 
   // Mark a small block at the corner of the hypercube
   std::vector<cell_iterator> ghost_cells_tria;
index 8bf1ea8f3c63b5510e4d543a0816e76e050f455c..6af27e0ac85e7da69c55d118d1ed251b4da0f4f0 100644 (file)
@@ -97,9 +97,8 @@ test_periodic_cube()
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria, -1.0, 1.0, true);
 
-  typedef GridTools::PeriodicFacePair<
-    typename Triangulation<dim>::cell_iterator>
-                                  periodic_face_pair;
+  using periodic_face_pair =
+    GridTools::PeriodicFacePair<typename Triangulation<dim>::cell_iterator>;
   std::vector<periodic_face_pair> periodicity_vector;
   GridTools::collect_periodic_faces(tria, 0, 1, 0, periodicity_vector);
   tria.add_periodicity(periodicity_vector);
index ba8400207172e8c13155276fb139e4bc47065dc9..f8f46f1016c3a64600cbbfe51875fdf768f94caa 100644 (file)
@@ -349,7 +349,7 @@ namespace LaplaceSolver
   void
   Solver<dim>::assemble_linear_system(LinearSystem &linear_system)
   {
-    typedef typename DoFHandler<dim>::active_cell_iterator active_cell_iterator;
+    using active_cell_iterator = typename DoFHandler<dim>::active_cell_iterator;
 
     const unsigned int n_threads = MultithreadInfo::n_threads();
     std::vector<std::pair<active_cell_iterator, active_cell_iterator>>
index 120e26a171c6af9b4f94c737c2a38d1523e18b9c..c84ac80709cc36da690db8e7725ad874edf774ca 100644 (file)
@@ -49,7 +49,7 @@ template <int dim>
 class Local : public Subscriptor
 {
 public:
-  typedef EmptyInfo CellInfo;
+  using CellInfo = EmptyInfo;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index d29ebf040fdad9776144ab40ec2f62878c8f0e71..ebd2cda6862b824bcb40fac8b6f5de9ed781e210 100644 (file)
@@ -30,7 +30,7 @@ public:
 class EmptyInfoBox
 {
 public:
-  typedef EmptyInfo CellInfo;
+  using CellInfo = EmptyInfo;
   template <int dim, class DOFINFO>
   void
   post_cell(const MeshWorker::DoFInfoBox<dim, DOFINFO> &)
index 6668bddcdbe565f5f1133735a34dc9b1c59833b8..5c8f88eaff27e6ff8eda3934d3400e5a4f4e7b79 100644 (file)
@@ -47,7 +47,7 @@ template <int dim>
 class Local : public Subscriptor
 {
 public:
-  typedef EmptyInfo CellInfo;
+  using CellInfo = EmptyInfo;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index b9e42f8806252b01aa5ee84049614c62f699095d..2fcedc565ff42aef77b6104e373ad76c3bc2bcf2 100644 (file)
@@ -43,7 +43,7 @@ template <int dim>
 class Local : public Subscriptor
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index 0e5f0b9626bd1588dfc2af0bf66cc34b7f3c7a23..e8e8b333701fe51a5bc1f0814076718ad5739a9b 100644 (file)
@@ -44,7 +44,7 @@ template <int dim>
 class Local : public Subscriptor
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index e482dcef4d66ee057fdbd7ce3d8fd3bc40ac4287..6900b21cd9cc471a0e3fe6813b9b00cf0cb1719d 100644 (file)
@@ -42,9 +42,8 @@ main(int argc, char *argv[])
 
   auto op_b = linear_operator<TrilinosWrappers::MPI::BlockVector>(b);
 
-  typedef LinearOperator<TrilinosWrappers::MPI::Vector,
-                         TrilinosWrappers::MPI::Vector>
-    Op_MPI;
+  using Op_MPI = LinearOperator<TrilinosWrappers::MPI::Vector,
+                                TrilinosWrappers::MPI::Vector>;
 
   auto op_c = block_diagonal_operator<2, TrilinosWrappers::MPI::BlockVector>(
     std::array<Op_MPI, 2>({{op_a, op_a}}));
index 8212144efd0d3717317a63c3a0719f99472d8b67..0aee865ffd95cffcba524b16079e16ec4d96eba6 100644 (file)
@@ -117,8 +117,8 @@ test()
       AssertThrow(correct_constraints.is_constrained(i) ==
                     library_constraints.is_constrained(i),
                   ExcInternalError());
-      typedef const std::vector<std::pair<types::global_dof_index, double>>
-        &constraint_format;
+      using constraint_format =
+        const std::vector<std::pair<types::global_dof_index, double>> &;
       if (correct_constraints.is_constrained(i))
         {
           constraint_format correct =
index cfedbd588ff2e83f06408f4c9605885daa251268..c9595863117810010692e1115aa9085445c0c6f9 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree>
 void
 test(const bool hanging_nodes = true)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 1724b4e1e95ab3e9df730ad2c76ce254145eb2c2..d8014177eb2b7f4b7c9e8e07057e0692e1a9c851 100644 (file)
@@ -27,8 +27,8 @@
 
 struct LeftVector
 {
-  typedef double value_type;
-  value_type     value;
+  using value_type = double;
+  value_type value;
 
   LeftVector &
   operator=(value_type new_value)
@@ -68,8 +68,8 @@ struct LeftVector
 
 struct RightVector
 {
-  typedef double value_type;
-  value_type     value;
+  using value_type = double;
+  value_type value;
 
   RightVector &
   operator=(value_type new_value)
@@ -114,7 +114,7 @@ main()
 
   // Create to distinct linear operators:
 
-  typedef dealii::internal::LinearOperatorImplementation::EmptyPayload Payload;
+  using Payload = dealii::internal::LinearOperatorImplementation::EmptyPayload;
   LinearOperator<LeftVector, RightVector, Payload> multiply2;
   multiply2.vmult = [](LeftVector &v, const RightVector &u) {
     v.value = 2 * u.value;
index dc35fe628213af965bd9de6c5b1fd65912241b2e..a7026d714a490a6a6b2eec79b0e037f44dc142d0 100644 (file)
@@ -30,8 +30,8 @@
 
 struct LeftVector
 {
-  typedef std::complex<double> value_type;
-  value_type                   value;
+  using value_type = std::complex<double>;
+  value_type value;
 
   LeftVector &
   operator=(value_type new_value)
@@ -71,8 +71,8 @@ struct LeftVector
 
 struct RightVector
 {
-  typedef std::complex<double> value_type;
-  value_type                   value;
+  using value_type = std::complex<double>;
+  value_type value;
 
   RightVector &
   operator=(value_type new_value)
@@ -117,7 +117,7 @@ main()
 
   // Create to distinct linear operators:
 
-  typedef dealii::internal::LinearOperatorImplementation::EmptyPayload Payload;
+  using Payload = dealii::internal::LinearOperatorImplementation::EmptyPayload;
   LinearOperator<LeftVector, RightVector, Payload> multiply2;
   multiply2.vmult = [](LeftVector &v, const RightVector &u) {
     v.value = 2. * u.value;
index 6f006514421d4fafd94afaab393b9e8c6911a131..a4da501e1abfec70fdde18afbd3aad99c1162359 100644 (file)
@@ -32,8 +32,8 @@ main(int argc, char *argv[])
   initlog();
   deallog << std::setprecision(10);
 
-  typedef TrilinosWrappers::MPI::Vector  vector_t;
-  typedef TrilinosWrappers::SparseMatrix matrix_t;
+  using vector_t = TrilinosWrappers::MPI::Vector;
+  using matrix_t = TrilinosWrappers::SparseMatrix;
 
   matrix_t a(5U, 5U, 3U);
   a.compress(VectorOperation::add);
index 2497cb90ee7513d907cad28d45739f75a8bea69c..586075518025f23eaa6db21e08b2b0f5247e164c 100644 (file)
@@ -235,30 +235,30 @@ main()
 
     {
       deallog << "PreconditionChebyshev" << std::endl;
-      typedef PreconditionChebyshev<SparseMatrix<double>> PREC;
+      using PREC = PreconditionChebyshev<SparseMatrix<double>>;
       test_preconditioner<PREC>(A, b);
     }
     {
       deallog << "PreconditionIdentity" << std::endl;
-      typedef PreconditionIdentity PREC;
+      using PREC = PreconditionIdentity;
       test_preconditioner<PREC>(A, b);
     }
     {
       deallog << "PreconditionJacobi" << std::endl;
-      typedef PreconditionJacobi<SparseMatrix<double>> PREC;
+      using PREC = PreconditionJacobi<SparseMatrix<double>>;
       test_preconditioner<PREC>(A, b);
     }
     {
       deallog << "PreconditionPSOR" << std::endl;
-      typedef PreconditionPSOR<SparseMatrix<double>> PREC;
-      std::vector<PREC::size_type>                   permutation(b.size());
+      using PREC = PreconditionPSOR<SparseMatrix<double>>;
+      std::vector<PREC::size_type> permutation(b.size());
       std::vector<PREC::size_type> inverse_permutation(b.size());
       test_preconditioner<PREC>(
         A, b, typename PREC::AdditionalData(permutation, inverse_permutation));
     }
     {
       deallog << "PreconditionRichardson" << std::endl;
-      typedef PreconditionRichardson PREC;
+      using PREC = PreconditionRichardson;
       test_preconditioner<PREC>(A, b);
     }
     {
@@ -283,28 +283,28 @@ main()
     }
     {
       deallog << "PreconditionSOR" << std::endl;
-      typedef PreconditionSOR<SparseMatrix<double>> PREC;
+      using PREC = PreconditionSOR<SparseMatrix<double>>;
       test_preconditioner<PREC>(A, b);
     }
     {
       deallog << "PreconditionSSOR" << std::endl;
-      typedef PreconditionSSOR<SparseMatrix<double>> PREC;
+      using PREC = PreconditionSSOR<SparseMatrix<double>>;
       test_preconditioner<PREC>(A, b);
     }
     {
       deallog << "SparseILU" << std::endl;
-      typedef SparseILU<double> PREC;
+      using PREC = SparseILU<double>;
       test_preconditioner<PREC>(A, b);
     }
     {
       deallog << "SparseMIC" << std::endl;
-      typedef SparseMIC<double> PREC;
+      using PREC = SparseMIC<double>;
       test_preconditioner<PREC>(A, b);
     }
     {
       deallog << "SparseVanka" << std::endl;
-      typedef SparseVanka<double>           PREC;
-      typedef typename PREC::AdditionalData PREC_AD;
+      using PREC    = SparseVanka<double>;
+      using PREC_AD = typename PREC::AdditionalData;
       test_preconditioner<PREC>(A, b, PREC_AD(std::vector<bool>(rc, true)));
     }
     deallog.pop();
@@ -316,42 +316,42 @@ main()
 
     {
       deallog << "SolverBicgstab" << std::endl;
-      typedef SolverBicgstab<Vector<double>> SLVR;
+      using SLVR = SolverBicgstab<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
       deallog << "SolverCG" << std::endl;
-      typedef SolverCG<Vector<double>> SLVR;
+      using SLVR = SolverCG<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
       deallog << "SolverFGMRES" << std::endl;
-      typedef SolverFGMRES<Vector<double>> SLVR;
+      using SLVR = SolverFGMRES<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
       deallog << "SolverGMRES" << std::endl;
-      typedef SolverGMRES<Vector<double>> SLVR;
+      using SLVR = SolverGMRES<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
       deallog << "SolverMinRes" << std::endl;
-      typedef SolverMinRes<Vector<double>> SLVR;
+      using SLVR = SolverMinRes<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
       deallog << "SolverQMRS" << std::endl;
-      typedef SolverQMRS<Vector<double>> SLVR;
+      using SLVR = SolverQMRS<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
       deallog << "SolverRelaxation" << std::endl;
-      typedef SolverRelaxation<Vector<double>> SLVR;
+      using SLVR = SolverRelaxation<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
       deallog << "SolverRichardson" << std::endl;
-      typedef SolverRichardson<Vector<double>> SLVR;
+      using SLVR = SolverRichardson<Vector<double>>;
       test_solver<SLVR>(A, b);
     }
     {
@@ -416,7 +416,7 @@ main()
     // === PRECONDITIONERS ===
     {
       deallog << "PreconditionBlockIdentity" << std::endl;
-      typedef PreconditionBlockIdentity<SparseMatrix<double>> PREC;
+      using PREC = PreconditionBlockIdentity<SparseMatrix<double>>;
       test_preconditioner_block<PREC>(A, b);
     }
 
index 02c27a2bd4b5e077856199701ce17808c0459edf..f9dc5920737643dd604a57112f07bae8c6573620 100644 (file)
@@ -34,7 +34,7 @@
 int
 main(int argc, char *argv[])
 {
-  typedef PETScWrappers::MPI::SparseMatrix::size_type size_type;
+  using size_type = PETScWrappers::MPI::SparseMatrix::size_type;
 
   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
 
index 5a413674048503239d226d5733bf6fdee1866f9b..c579c4d7c13c2ef0adf70f078155c7e6076d5e0e 100644 (file)
@@ -60,9 +60,9 @@ test_preconditioner(const MATRIX &         A,
   PRECONDITIONER preconditioner;
   preconditioner.initialize(A, data);
 
-  typedef TrilinosWrappers::SolverCG SOLVER;
-  SolverControl                      solver_control(100, 1.0e-10);
-  SOLVER                             solver(solver_control);
+  using SOLVER = TrilinosWrappers::SolverCG;
+  SolverControl solver_control(100, 1.0e-10);
+  SOLVER        solver(solver_control);
 
   // Exact inverse
   const auto lo_A_inv = inverse_operator(lo_A, solver, preconditioner);
@@ -125,9 +125,9 @@ test_preconditioner(const MATRIX &         A,
   {
     // Stand-alone
     deallog.push("S.A.");
-    typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload PAYLOAD;
-    const auto        lo_A_inv_approx =
+    using PAYLOAD = dealii::TrilinosWrappers::internal::
+      LinearOperatorImplementation::TrilinosPayload;
+    const auto lo_A_inv_approx =
       linear_operator<VECTOR, VECTOR, PAYLOAD>(preconditioner);
 
     // Singular operation
@@ -165,8 +165,8 @@ test_solver(const MATRIX &A, const VECTOR &b)
   SolverControl solver_control(100, 1.0e-10);
   SOLVER        solver(solver_control);
 
-  typedef TrilinosWrappers::PreconditionJacobi PRECONDITIONER;
-  PRECONDITIONER                               preconditioner;
+  using PRECONDITIONER = TrilinosWrappers::PreconditionJacobi;
+  PRECONDITIONER preconditioner;
   preconditioner.initialize(A);
 
   {
@@ -248,7 +248,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionAMG");
-      typedef TrilinosWrappers::PreconditionAMG PREC;
+      using PREC = TrilinosWrappers::PreconditionAMG;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -257,7 +257,7 @@ main(int argc, char *argv[])
 #ifdef DEAL_II_TRILINOS_WITH_MUELU
     {
       deallog.push("PreconditionAMGMueLu");
-      typedef TrilinosWrappers::PreconditionAMGMueLu PREC;
+      using PREC = TrilinosWrappers::PreconditionAMGMueLu;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -266,7 +266,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionChebyshev");
-      typedef TrilinosWrappers::PreconditionChebyshev PREC;
+      using PREC = TrilinosWrappers::PreconditionChebyshev;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -274,7 +274,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionIC");
-      typedef TrilinosWrappers::PreconditionIC PREC;
+      using PREC = TrilinosWrappers::PreconditionIC;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -282,7 +282,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionIdentity");
-      typedef TrilinosWrappers::PreconditionIdentity PREC;
+      using PREC = TrilinosWrappers::PreconditionIdentity;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -290,7 +290,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionILU");
-      typedef TrilinosWrappers::PreconditionILU PREC;
+      using PREC = TrilinosWrappers::PreconditionILU;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -298,7 +298,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionILUT");
-      typedef TrilinosWrappers::PreconditionILUT PREC;
+      using PREC = TrilinosWrappers::PreconditionILUT;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -306,7 +306,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionJacobi");
-      typedef TrilinosWrappers::PreconditionJacobi PREC;
+      using PREC = TrilinosWrappers::PreconditionJacobi;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -314,7 +314,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionSOR");
-      typedef TrilinosWrappers::PreconditionSOR PREC;
+      using PREC = TrilinosWrappers::PreconditionSOR;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -322,7 +322,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionSSOR");
-      typedef TrilinosWrappers::PreconditionSSOR PREC;
+      using PREC = TrilinosWrappers::PreconditionSSOR;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -342,7 +342,7 @@ main(int argc, char *argv[])
           // Note: Even though this test fails, we would still like to check
           //       that we can build LinearOperators with this solver
           deallog.push("SolverBicgstab");
-          typedef TrilinosWrappers::SolverBicgstab SLVR;
+          using SLVR = TrilinosWrappers::SolverBicgstab;
           test_solver<SLVR>(A, b);
           deallog.pop();
         }
@@ -356,14 +356,14 @@ main(int argc, char *argv[])
 
     {
       deallog.push("SolverCG");
-      typedef TrilinosWrappers::SolverCG SLVR;
+      using SLVR = TrilinosWrappers::SolverCG;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverCGS");
-      typedef TrilinosWrappers::SolverCGS SLVR;
+      using SLVR = TrilinosWrappers::SolverCGS;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
@@ -372,10 +372,10 @@ main(int argc, char *argv[])
     // the LinearOperator class.
     // {
     //   deallog.push("SolverDirect");
-    //   typedef TrilinosWrappers::SolverDirect SLVR;
+    //   using SLVR = TrilinosWrappers::SolverDirect;
     //   // test_solver<SLVR> (A, b);
     //
-    //   typedef dealii::TrilinosWrappers::MPI::Vector VectorType;
+    //   using VectorType = dealii::TrilinosWrappers::MPI::Vector;
     //   typedef
     //   dealii::TrilinosWrappers::internal::LinearOperatorImplementation::TrilinosPayload
     //   PayloadType;
@@ -415,7 +415,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("SolverGMRES");
-      typedef TrilinosWrappers::SolverGMRES SLVR;
+      using SLVR = TrilinosWrappers::SolverGMRES;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
@@ -427,7 +427,7 @@ main(int argc, char *argv[])
           // Note: Even though this test fails, we would still like to check
           //       that we can build LinearOperators with this solver
           deallog.push("SolverTFQMR");
-          typedef TrilinosWrappers::SolverTFQMR SLVR;
+          using SLVR = TrilinosWrappers::SolverTFQMR;
           test_solver<SLVR>(A, b);
           deallog.pop();
         }
index 27f2212747dc2b0359958f5a930475768a9620ef..411461223d0ce3354a5f450aeeb35b3d892d1e8b 100644 (file)
@@ -65,9 +65,9 @@ test_preconditioner(const MATRIX &         A,
   PRECONDITIONER preconditioner;
   preconditioner.initialize(A, data);
 
-  typedef SolverCG<VECTOR> SOLVER;
-  SolverControl            solver_control(100, 1.0e-10, false, false);
-  SOLVER                   solver(solver_control);
+  using SOLVER = SolverCG<VECTOR>;
+  SolverControl solver_control(100, 1.0e-10, false, false);
+  SOLVER        solver(solver_control);
 
   // Exact inverse
   const auto lo_A_inv = inverse_operator(lo_A, solver, preconditioner);
@@ -130,9 +130,9 @@ test_preconditioner(const MATRIX &         A,
   {
     // Stand-alone
     deallog.push("S.A.");
-    typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::
-      TrilinosPayload PAYLOAD;
-    const auto        lo_A_inv_approx =
+    using PAYLOAD = dealii::TrilinosWrappers::internal::
+      LinearOperatorImplementation::TrilinosPayload;
+    const auto lo_A_inv_approx =
       linear_operator<VECTOR, VECTOR, PAYLOAD>(preconditioner);
 
     // Singular operation
@@ -170,8 +170,8 @@ test_solver(const MATRIX &A, const VECTOR &b)
   SolverControl solver_control(100, 1.0e-10, false, false);
   SOLVER        solver(solver_control);
 
-  typedef TrilinosWrappers::PreconditionJacobi PRECONDITIONER;
-  PRECONDITIONER                               preconditioner;
+  using PRECONDITIONER = TrilinosWrappers::PreconditionJacobi;
+  PRECONDITIONER preconditioner;
   preconditioner.initialize(A);
 
   {
@@ -253,7 +253,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionAMG");
-      typedef TrilinosWrappers::PreconditionAMG PREC;
+      using PREC = TrilinosWrappers::PreconditionAMG;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -262,7 +262,7 @@ main(int argc, char *argv[])
 #ifdef DEAL_II_TRILINOS_WITH_MUELU
     {
       deallog.push("PreconditionAMGMueLu");
-      typedef TrilinosWrappers::PreconditionAMGMueLu PREC;
+      using PREC = TrilinosWrappers::PreconditionAMGMueLu;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -271,7 +271,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionChebyshev");
-      typedef TrilinosWrappers::PreconditionChebyshev PREC;
+      using PREC = TrilinosWrappers::PreconditionChebyshev;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -279,7 +279,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionIC");
-      typedef TrilinosWrappers::PreconditionIC PREC;
+      using PREC = TrilinosWrappers::PreconditionIC;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -287,7 +287,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionIdentity");
-      typedef TrilinosWrappers::PreconditionIdentity PREC;
+      using PREC = TrilinosWrappers::PreconditionIdentity;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -295,7 +295,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionILU");
-      typedef TrilinosWrappers::PreconditionILU PREC;
+      using PREC = TrilinosWrappers::PreconditionILU;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -303,7 +303,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionILUT");
-      typedef TrilinosWrappers::PreconditionILUT PREC;
+      using PREC = TrilinosWrappers::PreconditionILUT;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -311,7 +311,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionJacobi");
-      typedef TrilinosWrappers::PreconditionJacobi PREC;
+      using PREC = TrilinosWrappers::PreconditionJacobi;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -319,7 +319,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionSOR");
-      typedef TrilinosWrappers::PreconditionSOR PREC;
+      using PREC = TrilinosWrappers::PreconditionSOR;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -327,7 +327,7 @@ main(int argc, char *argv[])
 
     {
       deallog.push("PreconditionSSOR");
-      typedef TrilinosWrappers::PreconditionSSOR PREC;
+      using PREC = TrilinosWrappers::PreconditionSSOR;
       test_preconditioner<PREC>(A, b);
       test_preconditioner<PREC>(A, c);
       deallog.pop();
@@ -342,49 +342,49 @@ main(int argc, char *argv[])
 
     {
       deallog.push("SolverBicgstab");
-      typedef SolverBicgstab<TrilinosWrappers::MPI::Vector> SLVR;
+      using SLVR = SolverBicgstab<TrilinosWrappers::MPI::Vector>;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverCG");
-      typedef SolverCG<TrilinosWrappers::MPI::Vector> SLVR;
+      using SLVR = SolverCG<TrilinosWrappers::MPI::Vector>;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverGMRES");
-      typedef SolverGMRES<TrilinosWrappers::MPI::Vector> SLVR;
+      using SLVR = SolverGMRES<TrilinosWrappers::MPI::Vector>;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverFGMRES");
-      typedef SolverFGMRES<TrilinosWrappers::MPI::Vector> SLVR;
+      using SLVR = SolverFGMRES<TrilinosWrappers::MPI::Vector>;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverMinRes");
-      typedef SolverMinRes<TrilinosWrappers::MPI::Vector> SLVR;
+      using SLVR = SolverMinRes<TrilinosWrappers::MPI::Vector>;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverQMRS");
-      typedef SolverQMRS<TrilinosWrappers::MPI::Vector> SLVR;
+      using SLVR = SolverQMRS<TrilinosWrappers::MPI::Vector>;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
 
     {
       deallog.push("SolverRichardson");
-      typedef SolverRichardson<TrilinosWrappers::MPI::Vector> SLVR;
+      using SLVR = SolverRichardson<TrilinosWrappers::MPI::Vector>;
       test_solver<SLVR>(A, b);
       deallog.pop();
     }
index 4d7f9cdcd0a5cc9a84ad1fdcd2e6295bac485788..937c8d113bcbeb873bf57a0ad1cf17a0cc056229 100644 (file)
@@ -236,8 +236,8 @@ Step4<dim>::solve()
     deallog.pop();
   }
 
-  typedef TrilinosWrappers::MPI::Vector VectorType;
-  VectorType                            output(solution);
+  using VectorType = TrilinosWrappers::MPI::Vector;
+  VectorType output(solution);
   {
     deallog.push("Trilinos_CG_SSOR");
     output = 0;
index 1d58b116ec09a4641fc4ef7db167fed5b6c88d20..5ae900a8f817a71c2445c0880e2e4082a253b37f 100644 (file)
@@ -284,7 +284,7 @@ template <int dim>
 void
 Step4<dim>::solve()
 {
-  typedef TrilinosWrappers::MPI::Vector VectorType;
+  using VectorType = TrilinosWrappers::MPI::Vector;
 
   // Compute 'reference' solution with direct solver
   VectorType temp_solution(system_rhs);
index 95cbdf2277f1fd357df362958c7ad9955d9246bb..4dcf0bd96c783dc602bc17401cac5018fd5dc00d 100644 (file)
@@ -285,7 +285,7 @@ template <int dim>
 void
 Step4<dim>::solve()
 {
-  typedef TrilinosWrappers::MPI::Vector VectorType;
+  using VectorType = TrilinosWrappers::MPI::Vector;
 
   // Compute 'reference' solution with direct solver
   VectorType temp_solution(system_rhs);
index 3687dbaa2336cda554429638176ae16aa8592769..15b7474e52818995ccfcbb11c8b8601fd710d3f6 100644 (file)
@@ -143,13 +143,13 @@ void
 evaluate_ops(const TrilinosWrappers::BlockSparseMatrix &matrix,
              const TrilinosWrappers::MPI::BlockVector & vector)
 {
-  const double                                   tol = 1e-12;
-  typedef dealii::TrilinosWrappers::SparseMatrix MatrixType;
-  typedef dealii::TrilinosWrappers::MPI::Vector  VectorType;
-  typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::
-    TrilinosPayload                        PayloadType;
-  typedef typename PayloadType::VectorType PayloadVectorType;
-  typedef dealii::types::global_dof_index  size_type;
+  const double tol  = 1e-12;
+  using MatrixType  = dealii::TrilinosWrappers::SparseMatrix;
+  using VectorType  = dealii::TrilinosWrappers::MPI::Vector;
+  using PayloadType = dealii::TrilinosWrappers::internal::
+    LinearOperatorImplementation::TrilinosPayload;
+  using PayloadVectorType = typename PayloadType::VectorType;
+  using size_type         = dealii::types::global_dof_index;
 
   deallog.push("System info");
   {
index 55d68d263f37b2a37122fb57382ccdc8e755b859..dd4748584428834218616cfcbf862892a44bc8a7 100644 (file)
@@ -189,13 +189,13 @@ void
 evaluate_ops(const TrilinosWrappers::BlockSparseMatrix &matrix,
              const TrilinosWrappers::MPI::BlockVector & vector)
 {
-  const double                                   tol = 1e-12;
-  typedef dealii::TrilinosWrappers::SparseMatrix MatrixType;
-  typedef dealii::TrilinosWrappers::MPI::Vector  VectorType;
-  typedef dealii::TrilinosWrappers::internal::LinearOperatorImplementation::
-    TrilinosPayload                        PayloadType;
-  typedef typename PayloadType::VectorType PayloadVectorType;
-  typedef dealii::types::global_dof_index  size_type;
+  const double tol  = 1e-12;
+  using MatrixType  = dealii::TrilinosWrappers::SparseMatrix;
+  using VectorType  = dealii::TrilinosWrappers::MPI::Vector;
+  using PayloadType = dealii::TrilinosWrappers::internal::
+    LinearOperatorImplementation::TrilinosPayload;
+  using PayloadVectorType = typename PayloadType::VectorType;
+  using size_type         = dealii::types::global_dof_index;
 
   deallog.push("System info");
   {
index 1ff91bb7ad0a63fb56c3202525a1bf3318ca485b..c42313129a17c99728332d85d5f173371dd4f8bb 100644 (file)
@@ -32,8 +32,8 @@ main(int argc, char *argv[])
   initlog();
   deallog << std::setprecision(10);
 
-  typedef LinearAlgebra::distributed::Vector<double> vector_t;
-  typedef TrilinosWrappers::SparseMatrix             matrix_t;
+  using vector_t = LinearAlgebra::distributed::Vector<double>;
+  using matrix_t = TrilinosWrappers::SparseMatrix;
 
   matrix_t a(5U, 4U, 3U);
   a.compress(VectorOperation::add);
index aff4f82edfc2e8a9358460e722009deeae9dbd5d..3225a2a4e4e320a5707e80b4de0d2a608369a6ed 100644 (file)
@@ -62,8 +62,8 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
-  QR<VectorType>         qr;
+  using VectorType = Vector<number>;
+  QR<VectorType> qr;
 
   const unsigned int v_size = 5;
   VectorType         v(v_size);
index b6d7757098fb1a0ec53f419c3a42950ca9dd1400..886d9bdcb9d49705cb7b9a81cc04efb62f7ecfe4 100644 (file)
@@ -101,8 +101,8 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
-  QR<VectorType>         qr;
+  using VectorType = Vector<number>;
+  QR<VectorType> qr;
 
   auto print_givens = [](const unsigned int           i,
                          const unsigned int           j,
index d23f77f7855d814e5653d55ce99765874007eeee..d9286b288419ccd63078c7b7c4751aa8893eb0aa 100644 (file)
@@ -64,7 +64,7 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
   ImplicitQR<VectorType> qr;
 
   const unsigned int v_size = 5;
index bc8924607dcbe887ca8b9a3f0bce89e7b3d3eee7..8af5e33c9145fec812b012959f99a6e4afbdc292 100644 (file)
@@ -101,7 +101,7 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
   ImplicitQR<VectorType> qr;
 
   auto print_givens = [](const unsigned int           i,
index ad1157e689c292acae6a12c1201df637ee5fffb5..ec6125f0c493346dbce7433fc9b9cb4685d54a76 100644 (file)
@@ -54,8 +54,8 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
-  QR<VectorType>         qr;
+  using VectorType = Vector<number>;
+  QR<VectorType> qr;
 
   const unsigned int v_size = 5;
   VectorType         v(v_size);
index dafd9b1ec8020bc8d0768c5200c4fefd68840a05..34a830aefc6a7eecda033a3f90ddafd571191b23 100644 (file)
@@ -58,8 +58,8 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
-  QR<VectorType>         qr;
+  using VectorType = Vector<number>;
+  QR<VectorType> qr;
 
   const unsigned int v_size = 5;
   VectorType         v(v_size);
index ba4f812478b856eb7fbd028abfe3f1a7a0f3b33d..7dff22e0e53acae29db2bd9dcdba8a32dcf8b792 100644 (file)
@@ -59,7 +59,7 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
   ImplicitQR<VectorType> qr;
 
   const unsigned int v_size = 5;
index bcb4b0387282d2110db91927b3e4c3b0a13d2dae..51debcdee1a4ba189a619a0093777f8e1c6cc8cb 100644 (file)
@@ -139,8 +139,8 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
-  QR<VectorType>         qr;
+  using VectorType = Vector<number>;
+  QR<VectorType> qr;
 
   const unsigned int v_size = 6;
   VectorType         v(v_size);
index dc82cbb78e0de88f8a607388d7d07ee8f32516ba..d9b10dc28d626da3a076bcc65c34494314ec7d78 100644 (file)
@@ -123,7 +123,7 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
   QR<VectorType>         qr;
   ImplicitQR<VectorType> pqr;
 
index 52f8c60be2c310b365876c68b9ad0bf63a26c19b..28b0097697102a7b4b772c03467508136253c304 100644 (file)
@@ -66,7 +66,7 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
   ImplicitQR<VectorType> qr;
 
   const unsigned int v_size = 5;
index 2bf823d02c742a5dfab6eff636c0fc02c1189387..96c79fe1dc9d83e0e1c533f56eb06d774c542f84 100644 (file)
@@ -94,8 +94,8 @@ main(int argc, char **argv)
 
        */
 
-      const unsigned int                    rc = 1;
-      typedef TrilinosWrappers::MPI::Vector VectorType;
+      const unsigned int rc = 1;
+      using VectorType      = TrilinosWrappers::MPI::Vector;
 
       TrilinosWrappers::SparseMatrix A(rc, rc, rc);
       TrilinosWrappers::SparseMatrix B(rc, rc, rc);
index 929d10685f261c6dc36b4e1f0dff2ae0a78a1597..c27bc0e180a4b0eb6c1948ff85a01d2d3b6b39c0 100644 (file)
@@ -131,11 +131,11 @@ private:
       data, true, 0, 0, start_vector_component);
     FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_p(
       data, false, 0, 0, start_vector_component);
-    typedef typename FEFaceEvaluation<dim,
-                                      fe_degree,
-                                      n_q_points_1d,
-                                      n_components,
-                                      number>::value_type value_type;
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -175,12 +175,12 @@ private:
     const std::pair<unsigned int, unsigned int> &face_range) const
   {
     FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
-                                                          fe_eval(data, true, 0, 0, start_vector_component);
-    typedef typename FEFaceEvaluation<dim,
-                                      fe_degree,
-                                      n_q_points_1d,
-                                      n_components,
-                                      number>::value_type value_type;
+      fe_eval(data, true, 0, 0, start_vector_component);
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
index 4db30ed36418ac3498b7817068ef61941b7d6d71..5e7edd4829322e798e9198e5d965ae284305c065 100644 (file)
@@ -138,11 +138,11 @@ private:
       data, true, 0, 0, start_vector_component);
     FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_p(
       data, false, 0, 0, start_vector_component);
-    typedef typename FEFaceEvaluation<dim,
-                                      fe_degree,
-                                      n_q_points_1d,
-                                      n_components,
-                                      number>::value_type value_type;
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -182,12 +182,12 @@ private:
     const std::pair<unsigned int, unsigned int> &face_range) const
   {
     FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
-                                                          fe_eval(data, true, 0, 0, start_vector_component);
-    typedef typename FEFaceEvaluation<dim,
-                                      fe_degree,
-                                      n_q_points_1d,
-                                      n_components,
-                                      number>::value_type value_type;
+      fe_eval(data, true, 0, 0, start_vector_component);
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
index 230b332308c90fe189f528bfd849845865706d1c..17cd4cc2226ca5f00b9c9ebc13f4f33302d4ad4e 100644 (file)
@@ -137,11 +137,11 @@ private:
       data, true, 0, 0, start_vector_component);
     FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number> phi_p(
       data, false, 0, 0, start_vector_component);
-    typedef typename FEFaceEvaluation<dim,
-                                      fe_degree,
-                                      n_q_points_1d,
-                                      n_components,
-                                      number>::value_type value_type;
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
 
     const unsigned int n_vect = VectorizedArray<number>::size();
 
@@ -193,12 +193,12 @@ private:
     const std::pair<unsigned int, unsigned int> &face_range) const
   {
     FEFaceEvaluation<dim, fe_degree, n_q_points_1d, n_components, number>
-                                                          fe_eval(data, true, 0, 0, start_vector_component);
-    typedef typename FEFaceEvaluation<dim,
-                                      fe_degree,
-                                      n_q_points_1d,
-                                      n_components,
-                                      number>::value_type value_type;
+      fe_eval(data, true, 0, 0, start_vector_component);
+    using value_type = typename FEFaceEvaluation<dim,
+                                                 fe_degree,
+                                                 n_q_points_1d,
+                                                 n_components,
+                                                 number>::value_type;
 
     const unsigned int n_vect = VectorizedArray<number>::size();
 
index 5e200c5991e9429a6b38d32c5c92ada2bdfb3656..bdbfcdae9aa03d8510fe9bdb91895d6a96139a38 100644 (file)
@@ -51,7 +51,7 @@ template <int dim,
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
index 801a2abb526c71fd53d658fd85095c7fd41f58ea..6ed9c8baf7402f848417c75481b986d26fa5aff2 100644 (file)
@@ -56,8 +56,8 @@ template <int dim, int degree_p, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -68,7 +68,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number> vector_t;
+    using vector_t = VectorizedArray<Number>;
     // allocate FEEvaluation. This test will test proper alignment
     AlignedVector<FEEvaluation<dim, degree_p + 1, degree_p + 2, dim, Number>>
       velocity;
index 6df78f7b8f31c4416041ee2a2cc5300f9f62c9a9..0ab24550fa1275173526a140512bfc7a43bef383 100644 (file)
@@ -75,7 +75,7 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
+  using vector_t = VectorizedArray<Number>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -102,7 +102,7 @@ template <int dim, int fe_degree>
 void
 test(const FiniteElement<dim> &fe, const unsigned int n_iterations)
 {
-  typedef double number;
+  using number = double;
 
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
index d495d287fefd8993efff2b084d9f28ec963cbd49..ab305ef853134f0fd7a7521b9126b0c79d9d42c2 100644 (file)
@@ -208,7 +208,7 @@ test()
   AffineConstraints<double> constraints;
   constraints.close();
 
-  typedef double number;
+  using number = double;
 
   MatrixFree<dim, number> mf_data;
   {
index 5dcb0ff071de3c9060c51a60b38906eb69b51333..86c282b90d21f7fcfef77fd520f38d30adc9af43 100644 (file)
@@ -208,7 +208,7 @@ test()
   AffineConstraints<double> constraints;
   constraints.close();
 
-  typedef double number;
+  using number = double;
 
   MatrixFree<dim, number> mf_data;
   {
index 120b8d3b400ebeb81cbe3aba1c8aae3c3b5f916d..13be5776b41a356258af1431852ae93a7f1f83fa 100644 (file)
@@ -31,7 +31,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index 2bf3fd9c35b7bf69139c6b7b621f6f0805fc75f4..00ce36569e97db19183c3e42a3d77cbccbcba841 100644 (file)
@@ -30,7 +30,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index cb1432826ae3b5bef55eea57e3d3938f506809fd..0b836d9fa0010df58906ec0a2798ab55269c285a 100644 (file)
@@ -52,7 +52,7 @@ template <int dim,
 class MatrixFreeTest
 {
 public:
-  typedef std::vector<Vector<Number>> VectorType;
+  using VectorType = std::vector<Vector<Number>>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
@@ -206,7 +206,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double     number;
+  using number = double;
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
   tria.refine_global(1);
index c5e3851956f973b5c5e71d51fc783ff96f6fb5a9..e3792da3cffd08c8d503ff576b71cfe759d7ed52 100644 (file)
@@ -54,7 +54,7 @@ template <int dim,
 class MatrixFreeTest
 {
 public:
-  typedef std::vector<Vector<Number>> VectorType;
+  using VectorType = std::vector<Vector<Number>>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
@@ -247,7 +247,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double     number;
+  using number = double;
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
   tria.refine_global(1);
index 5fe59876e576fe52ba96c3b8076557f5ba03fa8d..1b9e7b01d4711bec8bae6a8c5b0f7afd56a01479 100644 (file)
@@ -52,7 +52,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index 7ca704858fcb02935a96321ad8ca06b707652135..4778e5ea489b2cf26a2048f96d0756f3d7ebe4ab 100644 (file)
@@ -38,7 +38,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index eb0072dd773abb6a71504aa9ad23619be0fd9bcd..fcd743e0f187e017ca42e276c413259baec4e0ba 100644 (file)
@@ -52,7 +52,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index 2d24772755d510b446338143d9c4886a51a3decc..945e5069928a25ec49793f0a1410b7508274ee8a 100644 (file)
@@ -48,7 +48,7 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef Vector<Number> VectorType;
+  using VectorType = Vector<Number>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index 89919d5ea8970739bf12e77fefd19f66fa1d2720..b8f72bc50924f6f8627b89889c554f22cb3eb7c5 100644 (file)
@@ -44,7 +44,7 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef Vector<Number> VectorType;
+  using VectorType = Vector<Number>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
index 4f5f3d0403744cccefeb302ef25ff702f605f44a..d5496289fbfd7e77c120d046698699181e99af3f 100644 (file)
@@ -49,7 +49,7 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef std::vector<Vector<Number> *> VectorType;
+  using VectorType = std::vector<Vector<Number> *>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
@@ -151,7 +151,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index e65ae60de02efc914c73379b6b026c51d0cc1ff5..fc2767347f640528dac32062b748b871106a0755 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef std::vector<Vector<Number>> VectorType;
+  using VectorType = std::vector<Vector<Number>>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
index e98c2a08092a17007f2e8a2532eeecc5b6bd9fc2..baabbdb981c96ca0337a0ec010c05ba1bf3ed6d3 100644 (file)
@@ -53,7 +53,7 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef std::vector<Vector<Number>> VectorType;
+  using VectorType = std::vector<Vector<Number>>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
index da80af12ed1072f087987c36f520fdd68ea86e62..f31a0ecba645928c0a1bcf9a00d01722704a0c69 100644 (file)
@@ -49,7 +49,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index a69c57974d051244b26a8520751b90b157c477af..789e234fa203701d4f55723df50e26e835cf238f 100644 (file)
@@ -89,8 +89,8 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
-  F<dim>         function(3, 1);
+  using number = double;
+  F<dim> function(3, 1);
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index ef666ea2e63dea79df17bd4dc161e36af6e64ce6..7e521ac181812d129d34b7374c86b786013677a7 100644 (file)
@@ -49,7 +49,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index ae347994c790a401561f35d642579ea280d81c69..7df8d5f886ef6e7dcd143d8f3b5dcbc36571c37b 100644 (file)
@@ -57,7 +57,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index aa12b4fc865754f0bf1435b945e4278382ee5d61..53c4d1cf1ce83799e06524ad8496556da86b802e 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 15e17d32f0eee403e481a49890b760b1d2ed92bb..b3cf9e1150ca43171ca258f0c2f403b1052bf5e7 100644 (file)
@@ -51,7 +51,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index ad6bbd6e2a103de5bc6a9063e2111c0e2d51001c..a25bb69ed245fc878f79131497cb41e937148785 100644 (file)
@@ -46,7 +46,7 @@ template <int dim>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 52b2b573d281919c0db0027626d409316d2a2de4..3fdb8e61f1c5ad99594f1b5c043e6b368f662cf3 100644 (file)
@@ -56,7 +56,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index e74ab0c0c60aaa68039ebafa6b3ea56c9f87930c..baa61d81e1bb2a12f674e1adfae426ab600f4c89 100644 (file)
@@ -49,7 +49,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index a67a8b3a885295541bfb520681134f1619afd9e7..5e21936dc23850e5141b249d9c8b292d22ac7e7a 100644 (file)
@@ -82,8 +82,8 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
+  using vector_t                     = VectorizedArray<Number>;
+  static const std::size_t n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -114,7 +114,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 52bbdfb85c7d0ee6e004c7160268efd131eb72fa..4518e9f50252e915574cc028750cdf50e137db9f 100644 (file)
@@ -82,8 +82,8 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
+  using vector_t                     = VectorizedArray<Number>;
+  static const std::size_t n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -112,7 +112,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index b481e5bbe8bdb04a1519fffba647181db69a5022..ee27059f77449587b358966cafd51d7d13b4aacf 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::shared::Triangulation<dim> tria(
     MPI_COMM_WORLD,
index 9088fdd9bcd02628ffe4f00ac76bbf2be11c632b..c1ba0f16d6201b85d8a9f4f1658b953c0bb0799a 100644 (file)
@@ -94,8 +94,8 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
+  using vector_t                     = VectorizedArray<Number>;
+  static const std::size_t n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -125,7 +125,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
index d4a054650b248dc24164bcbadff09a3caef1da17..85fef93c8bd3512e849a5148a711faa9e2718273 100644 (file)
@@ -84,8 +84,8 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
+  using vector_t                     = VectorizedArray<Number>;
+  static const std::size_t n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -115,7 +115,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
index eff583f7fc6b1060f8017dbc4448d60629652ca0..752af23c32fa5ce7321a8b06ff7bf347568e663a 100644 (file)
@@ -83,8 +83,8 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
+  using vector_t                     = VectorizedArray<Number>;
+  static const std::size_t n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -115,7 +115,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 6cf998969a92d3179ce6f0e43e9221741d165faa..fc4ca90bee53143b2b0c57e5238681a88185b473 100644 (file)
@@ -95,8 +95,8 @@ template <int dim, int fe_degree, typename Number>
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
-  static const std::size_t        n_vectors = VectorizedArray<Number>::size();
+  using vector_t                     = VectorizedArray<Number>;
+  static const std::size_t n_vectors = VectorizedArray<Number>::size();
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -127,7 +127,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 9791a6582303de2bd5ebc387ee33db6b0f9f2d74..4768e957d982bc28bd10320f3acd9dfc3525047a 100644 (file)
@@ -50,7 +50,7 @@ template <int dim,
 class MatrixFreeVariant
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
+  using vector_t = VectorizedArray<Number>;
 
   MatrixFreeVariant(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
index 2ed5668a925a218df693aa1c29b8cb39fa51652e..37ad92a2ec4afd99fda019a3f6cf8e5210d869e7 100644 (file)
@@ -99,7 +99,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 9323a28595b38475d3f07d404e44bfb338804930..ee6e9cb16db523ec71c58bb384f8f84ed84135fe 100644 (file)
@@ -57,8 +57,8 @@ template <int dim, int degree, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -69,7 +69,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                    vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree, degree + 1, dim, Number> phi(data);
     vector_t coeff = make_vectorized_array(global_coefficient);
 
index fb8a00ac7ced797e6e69bd26ec2d41f748a6a4e6..36765522245ce57249d9e6c2f6a5caf9f85e5a6b 100644 (file)
@@ -59,8 +59,8 @@ template <int dim, int degree, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -71,7 +71,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                    vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree, degree + 1, dim, Number> phi(data);
     vector_t coeff = make_vectorized_array(global_coefficient);
 
@@ -264,7 +264,7 @@ test()
 
   system_matrix.vmult(solution, system_rhs);
 
-  typedef std::vector<Vector<double>>        VectorType;
+  using VectorType = std::vector<Vector<double>>;
   MatrixFreeTest<dim, fe_degree, VectorType> mf(mf_data);
   mf.vmult(vec2, vec1);
 
index c2bdeccddfcfb0f232fe513ffb173a78d1f24b16..1ddd76e44b5e88ac09897a61ff105e879c601dfc 100644 (file)
@@ -136,13 +136,13 @@ private:
                      number,
                      VectorizedArrayType>
       fe_eval_neighbor(data, false);
-    typedef
+    using value_type =
       typename FEFaceEvaluation<dim,
                                 fe_degree,
                                 n_q_points_1d,
                                 n_components,
                                 number,
-                                VectorizedArrayType>::value_type value_type;
+                                VectorizedArrayType>::value_type;
     const int actual_degree = data.get_dof_handler().get_fe().degree;
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
@@ -202,13 +202,13 @@ private:
                      number,
                      VectorizedArrayType>
       fe_eval(data, true);
-    typedef
+    using value_type =
       typename FEFaceEvaluation<dim,
                                 fe_degree,
                                 n_q_points_1d,
                                 n_components,
                                 number,
-                                VectorizedArrayType>::value_type value_type;
+                                VectorizedArrayType>::value_type;
     const int actual_degree = data.get_dof_handler().get_fe().degree;
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -340,13 +340,13 @@ private:
                      number,
                      VectorizedArrayType>
       fe_eval_neighbor(data, false, 0, 0, start_vector_component);
-    typedef
+    using value_type =
       typename FEFaceEvaluation<dim,
                                 fe_degree,
                                 n_q_points_1d,
                                 n_components,
                                 number,
-                                VectorizedArrayType>::value_type value_type;
+                                VectorizedArrayType>::value_type;
     const int actual_degree = data.get_dof_handler().get_fe().degree;
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
@@ -408,13 +408,13 @@ private:
                      number,
                      VectorizedArrayType>
       fe_eval(data, true, 0, 0, start_vector_component);
-    typedef
+    using value_type =
       typename FEFaceEvaluation<dim,
                                 fe_degree,
                                 n_q_points_1d,
                                 n_components,
                                 number,
-                                VectorizedArrayType>::value_type value_type;
+                                VectorizedArrayType>::value_type;
     const int actual_degree = data.get_dof_handler().get_fe().degree;
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -578,13 +578,13 @@ private:
                      number,
                      VectorizedArrayType>
       phi_p(data, false, 0, 0, start_vector_component);
-    typedef
+    using value_type =
       typename FEFaceEvaluation<dim,
                                 fe_degree,
                                 n_q_points_1d,
                                 n_components,
                                 number,
-                                VectorizedArrayType>::value_type value_type;
+                                VectorizedArrayType>::value_type;
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
       {
@@ -626,14 +626,14 @@ private:
                      number,
                      VectorizedArrayType>
       fe_eval(data, true, 0, 0, start_vector_component);
-    typedef
+    using value_type =
       typename FEFaceEvaluation<dim,
                                 fe_degree,
                                 n_q_points_1d,
                                 n_components,
                                 number,
-                                VectorizedArrayType>::value_type value_type;
-    value_type                                                   u_plus;
+                                VectorizedArrayType>::value_type;
+    value_type u_plus;
     u_plus = make_vectorized_array<number, VectorizedArrayType::size()>(1.3);
 
     for (unsigned int face = face_range.first; face < face_range.second; face++)
index dbf4028d092dd84b6d9ec3298139c4197921b0fd..ac18292b62f9656cc6955e023f37f91e5921af21 100644 (file)
@@ -111,7 +111,7 @@ test()
   if (fe_degree > 1)
     return;
 
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index 660349b3d1b70e7651d1a1496da2fd328e2dd6d1..fe8915a07de2d7a57e0d7d39e5040e9e1096be5b 100644 (file)
@@ -76,7 +76,7 @@ test()
   if (fe_degree > 1)
     return;
 
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
index 0635b85abdceb297136a3565462fddb661bd3988..fbc2aceecb2fd8408fff03f3875549b7881e4eee 100644 (file)
@@ -117,7 +117,7 @@ test()
   if (fe_degree > 1)
     return;
 
-  typedef double                            number;
+  using number = double;
   const SphericalManifold<dim>              manifold;
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_ball(tria);
index 98ab770ba5b111fa4302ebbcadca1edc81c6a029..6a0fea3d971abc1151c3ac76febea444e603cf9e 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double number;
+  using number = double;
 
   Triangulation<dim> tria;
   GridGenerator::hyper_cube(tria);
index 8a77fccac98c73404cf3f90aee0ad7682e647865..03b8553f3e0722aecc7f678e7eaf70591ec7047b 100644 (file)
@@ -35,7 +35,7 @@ helmholtz_operator(const MatrixFree<dim, typename VectorType::value_type> &data,
                    const VectorType &                                      src,
                    const std::pair<unsigned int, unsigned int> &cell_range)
 {
-  typedef typename VectorType::value_type                Number;
+  using Number = typename VectorType::value_type;
   FEEvaluation<dim, fe_degree, n_q_points_1d, 1, Number> fe_eval(data);
   const unsigned int n_q_points = fe_eval.n_q_points;
 
@@ -66,8 +66,8 @@ helmholtz_operator_no_template(
   const unsigned int                                      active_fe_index,
   const unsigned int                                      active_quad_index)
 {
-  typedef typename VectorType::value_type Number;
-  FEEvaluation<dim, -1, 0, 1, Number>     fe_eval(
+  using Number = typename VectorType::value_type;
+  FEEvaluation<dim, -1, 0, 1, Number> fe_eval(
     data, 0, 0, 0, active_fe_index, active_quad_index);
   const unsigned int n_q_points = fe_eval.n_q_points;
 
@@ -96,7 +96,7 @@ template <int dim,
 class MatrixFreeTest
 {
 public:
-  typedef VectorizedArray<Number> vector_t;
+  using vector_t = VectorizedArray<Number>;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
index ccfbdec34cdf6a761c13e301b0a4816baf6fa50b..f074be9e4518f9a5cece5f17f4637baaea17589f 100644 (file)
@@ -83,8 +83,8 @@ test()
   system_matrix.reinit(sparsity);
 
   // setup MG levels
-  const unsigned int                       nlevels = tria.n_levels();
-  typedef MatrixFree<dim>                  MatrixFreeTestType;
+  const unsigned int nlevels = tria.n_levels();
+  using MatrixFreeTestType   = MatrixFree<dim>;
   MGLevelObject<MatrixFreeTestType>        mg_matrices;
   MGLevelObject<AffineConstraints<double>> mg_constraints;
   MGLevelObject<SparsityPattern>           mg_sparsities;
index 73ca41dcd78719c7b9cb00dae921120fa27d9a5d..0a4fc0316de3846ad29e5cc6528b57a5ba389c4a 100644 (file)
@@ -57,8 +57,8 @@ template <int dim, int degree_p, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -69,7 +69,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                            vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree_p + 1, degree_p + 2, dim, Number> velocity(data,
                                                                         0);
     FEEvaluation<dim, degree_p, degree_p + 2, 1, Number> pressure(data, 1);
@@ -295,7 +295,7 @@ test()
 
   system_matrix.vmult(solution, system_rhs);
 
-  typedef std::vector<Vector<double>>        VectorType;
+  using VectorType = std::vector<Vector<double>>;
   MatrixFreeTest<dim, fe_degree, VectorType> mf(mf_data);
   mf.vmult(vec2, vec1);
 
index 18253664bc8ef6e55f7c6b0ea89b4c89c1dd01de..00f0b6ed2e8631e396ba3ebb58204782e6a9dfca 100644 (file)
@@ -39,8 +39,8 @@ template <int dim, int degree_p, typename BlockVectorType>
 class MatrixFreeTest : public MatrixFreeOperators::Base<dim, BlockVectorType>
 {
 public:
-  typedef typename BlockVectorType::value_type                     Number;
-  typedef typename MatrixFreeOperators::Base<dim, BlockVectorType> Base;
+  using Number = typename BlockVectorType::value_type;
+  using Base   = typename MatrixFreeOperators::Base<dim, BlockVectorType>;
 
   void
   compute_diagonal()
@@ -62,7 +62,7 @@ protected:
     const BlockVectorType &                      src,
     const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                            vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree_p + 1, degree_p + 2, dim, Number> velocity(data,
                                                                         0);
     FEEvaluation<dim, degree_p, degree_p + 2, 1, Number> pressure(data, 1);
index 648a55c0cfff803c3e4166d6120f96253cb0c201..510c0b6949cb6aecad57d9d6ae77c5c00620d4f0 100644 (file)
@@ -60,8 +60,8 @@ template <int dim, int degree_p, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in)
@@ -73,7 +73,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                            vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree_p + 1, degree_p + 2, dim, Number> velocity(data,
                                                                         0,
                                                                         0,
index 7f4e88da902bc4b2436978d56f05a2fce87c290c..adcefb52111e9e36144c91953201a1196bcd6751 100644 (file)
@@ -57,8 +57,8 @@ template <int dim, int degree_p, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -69,7 +69,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                            vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree_p + 1, degree_p + 2, dim, Number> velocity(data,
                                                                         0);
     FEEvaluation<dim, degree_p, degree_p + 2, 1, Number> pressure(data, 1);
index f4f4d226cf67e9503f2fca57ca9664ef9daa374d..990e4a32266b197bca5c287b6feac42d798a1361 100644 (file)
@@ -54,8 +54,8 @@ template <int dim, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -66,7 +66,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>       vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, -1, 0, dim, Number> velocity(data, 0);
     FEEvaluation<dim, -1, 0, 1, Number>   pressure(data, 1);
 
index 53d3d1cf55e4ba573cb9c0806f646bf6631084f5..ffa91c7e282f494b0b8ce46cb8201c127d0f681a 100644 (file)
@@ -58,8 +58,8 @@ template <int dim, int degree_p, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -70,7 +70,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                            vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree_p + 1, degree_p + 2, dim, Number> velocity(data,
                                                                         0,
                                                                         0,
index 25e877dec72cdfc14dcd4c2791a0f48808b42b24..6a1b9fa2fee587d022057eb4aef07e069941320c 100644 (file)
@@ -58,8 +58,8 @@ template <int dim, int degree_p, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -70,7 +70,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>                            vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, degree_p + 1, degree_p + 2, dim, Number> velocity(data,
                                                                         0);
     FEEvaluation<dim, degree_p, degree_p + 2, 1, Number> pressure(data, 1);
@@ -297,7 +297,7 @@ test()
 
   system_matrix.vmult(solution, system_rhs);
 
-  typedef std::vector<Vector<double>>        VectorType;
+  using VectorType = std::vector<Vector<double>>;
   MatrixFreeTest<dim, fe_degree, VectorType> mf(mf_data);
   mf.vmult(vec2, vec1);
 
index 5996466cbe11fbe05dcfeab344881160ca4a5056..3512777ce085ee036ed2d5e920516a78504b3be5 100644 (file)
@@ -59,8 +59,8 @@ template <int dim, typename VectorType>
 class MatrixFreeTest
 {
 public:
-  typedef typename DoFHandler<dim>::active_cell_iterator CellIterator;
-  typedef double                                         Number;
+  using CellIterator = typename DoFHandler<dim>::active_cell_iterator;
+  using Number       = double;
 
   MatrixFreeTest(const MatrixFree<dim, Number> &data_in)
     : data(data_in){};
@@ -71,7 +71,7 @@ public:
               const VectorType &                           src,
               const std::pair<unsigned int, unsigned int> &cell_range) const
   {
-    typedef VectorizedArray<Number>       vector_t;
+    using vector_t = VectorizedArray<Number>;
     FEEvaluation<dim, -1, 0, dim, Number> velocity(data, 0);
     FEEvaluation<dim, -1, 0, 1, Number>   pressure(data, 1);
 
@@ -294,8 +294,8 @@ test(const unsigned int fe_degree)
 
   system_matrix.vmult(solution, system_rhs);
 
-  typedef std::vector<Vector<double>> VectorType;
-  MatrixFreeTest<dim, VectorType>     mf(mf_data);
+  using VectorType = std::vector<Vector<double>>;
+  MatrixFreeTest<dim, VectorType> mf(mf_data);
   mf.vmult(vec2, vec1);
 
   // Verification
index 08d012120a68988ab912656390097c0247b316f9..f8354ea66bb6940d228d9ffcd4d4edb91d63f401 100644 (file)
@@ -59,7 +59,7 @@ template <int dim, typename number = double>
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
@@ -545,7 +545,7 @@ do_test(const DoFHandler<dim> &dof, const unsigned int n_q_points_1d)
   in = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, number> LevelMatrixType;
+  using LevelMatrixType = LaplaceOperator<dim, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -558,9 +558,9 @@ do_test(const DoFHandler<dim> &dof, const unsigned int n_q_points_1d)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 4149a28792c6e2b2fc4874bcf69654deed5ecb15..8d51236ec07e62a8be4fa976f55f9e54c9c92dab 100644 (file)
@@ -58,7 +58,7 @@ template <int dim, typename number = double>
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
@@ -554,7 +554,7 @@ do_test(const DoFHandler<dim> &dof, const unsigned n_q_points_1d)
   in = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, number> LevelMatrixType;
+  using LevelMatrixType = LaplaceOperator<dim, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -568,9 +568,9 @@ do_test(const DoFHandler<dim> &dof, const unsigned n_q_points_1d)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 7b82ffe11b6e61192ac4622dad365ccc5240d1ac..f8281cddc7f8dbc168ebe6cede32e34d7cc0dd82 100644 (file)
@@ -59,7 +59,7 @@ template <int dim, typename number = double>
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
@@ -460,7 +460,7 @@ do_test(const DoFHandler<dim> &dof, const unsigned int n_q_points_1d)
   in = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, number> LevelMatrixType;
+  using LevelMatrixType = LaplaceOperator<dim, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -474,9 +474,9 @@ do_test(const DoFHandler<dim> &dof, const unsigned int n_q_points_1d)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 125c601dbb8a6800582b889ab09c3b6a2e53eb82..f0f085b4652855908c5725f9de7238246077d368 100644 (file)
@@ -363,8 +363,8 @@ do_test(const DoFHandler<dim> &dof)
   in = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim, fe_degree, n_q_points_1d, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -381,9 +381,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 502521d8a0e7e60f157290d4c0ebbb067de8cd8d..eec70419958408aabdfe5677d7123cb93f7a9bb2 100644 (file)
@@ -151,12 +151,12 @@ do_test(const DoFHandler<dim> &dof)
   in = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim,
-                          fe_degree,
-                          n_q_points_1d,
-                          1,
-                          LinearAlgebra::distributed::Vector<number>>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim,
+                    fe_degree,
+                    n_q_points_1d,
+                    1,
+                    LinearAlgebra::distributed::Vector<number>>;
 
   MGLevelObject<LevelMatrixType>         mg_matrices;
   MGLevelObject<MatrixFree<dim, number>> mg_level_data;
@@ -197,9 +197,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 112bdbcee09135af4ed10a367ea38fda6b913057..e249f0d769472c8115a5e49c153408ef734ec7d4 100644 (file)
@@ -539,8 +539,8 @@ do_test(const DoFHandler<dim> &dof)
       in.local_element(i) = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim, fe_degree, n_q_points_1d, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -565,9 +565,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index ab5be7e8286173f505f3d6570d557af9d6bbd776..a03fd425e3aa7561edebd2fd6b005c39fc26d7c3 100644 (file)
@@ -201,12 +201,12 @@ do_test(const DoFHandler<dim> &dof)
   }
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim,
-                          fe_degree,
-                          n_q_points_1d,
-                          1,
-                          LinearAlgebra::distributed::Vector<number>>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim,
+                    fe_degree,
+                    n_q_points_1d,
+                    1,
+                    LinearAlgebra::distributed::Vector<number>>;
 
   MGLevelObject<LevelMatrixType>         mg_matrices;
   MGLevelObject<MatrixFree<dim, number>> mg_level_data;
@@ -256,9 +256,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 69a95e3863142ccc0b65097071b1d596dab35d40..1c8582ba1f8f8b245c41110871305f908f151f1b 100644 (file)
@@ -58,7 +58,7 @@ template <int dim,
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
@@ -548,8 +548,8 @@ do_test(const DoFHandler<dim> &dof, const bool threaded)
       in.local_element(i) = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim, fe_degree, n_q_points_1d, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -575,9 +575,9 @@ do_test(const DoFHandler<dim> &dof, const bool threaded)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index f4ff27044fa059bb1f179c7972946109ad560894..ecd39e11ca6a64249e4fb1013fb8f1de3673bb71 100644 (file)
@@ -201,12 +201,12 @@ do_test(const DoFHandler<dim> &dof)
   }
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim,
-                          fe_degree,
-                          n_q_points_1d,
-                          1,
-                          LinearAlgebra::distributed::Vector<number>>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim,
+                    fe_degree,
+                    n_q_points_1d,
+                    1,
+                    LinearAlgebra::distributed::Vector<number>>;
 
   MGLevelObject<LevelMatrixType>         mg_matrices;
   MGLevelObject<MatrixFree<dim, number>> mg_level_data;
@@ -256,9 +256,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   mg::SmootherRelaxation<SMOOTHER, LinearAlgebra::distributed::Vector<number>>
     mg_smoother;
 
index 10af8b4820f6172b1c77ebd2e4b22ea86a14aafe..069f004b311c0c04bb0b98bd1a7ce170507cea6b 100644 (file)
@@ -55,7 +55,7 @@ template <int dim,
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
@@ -545,8 +545,8 @@ do_test(const DoFHandler<dim> &dof, const bool threaded)
       in.local_element(i) = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim, fe_degree, n_q_points_1d, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -572,9 +572,9 @@ do_test(const DoFHandler<dim> &dof, const bool threaded)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index b17a08d117b409406355a9e331101afc4533a41c..86a0078b8691a6feaa1c370e5059d089fb45e0ad 100644 (file)
@@ -79,8 +79,8 @@ template <int dim,
 class BlockLaplace : public Subscriptor
 {
 public:
-  typedef typename BlockVectorType::value_type value_type;
-  typedef typename BlockVectorType::size_type  size_type;
+  using value_type = typename BlockVectorType::value_type;
+  using size_type  = typename BlockVectorType::size_type;
 
   BlockLaplace()
     : Subscriptor()
@@ -293,11 +293,11 @@ do_test(const DoFHandler<dim> &dof, const unsigned int nb)
   }
 
   // set up multigrid in analogy to step-37
-  typedef BlockLaplace<dim,
-                       fe_degree,
-                       n_q_points_1d,
-                       LinearAlgebra::distributed::BlockVector<number>>
-    LevelMatrixType;
+  using LevelMatrixType =
+    BlockLaplace<dim,
+                 fe_degree,
+                 n_q_points_1d,
+                 LinearAlgebra::distributed::BlockVector<number>>;
 
   MGLevelObject<LevelMatrixType>         mg_matrices;
   MGLevelObject<MatrixFree<dim, number>> mg_level_data;
@@ -347,7 +347,7 @@ do_test(const DoFHandler<dim> &dof, const unsigned int nb)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionJacobi<LevelMatrixType> SMOOTHER;
+  using SMOOTHER = PreconditionJacobi<LevelMatrixType>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::BlockVector<number>>
index f83983f14977d57407a3b612cd334d428f6ed0db..3611bf46f41980e630edce2370822cc9da73a9f3 100644 (file)
@@ -202,12 +202,12 @@ do_test(const DoFHandler<dim> &dof)
   }
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim,
-                          fe_degree,
-                          n_q_points_1d,
-                          1,
-                          LinearAlgebra::distributed::Vector<number>>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim,
+                    fe_degree,
+                    n_q_points_1d,
+                    1,
+                    LinearAlgebra::distributed::Vector<number>>;
 
   MGLevelObject<LevelMatrixType>         mg_matrices;
   MGLevelObject<MatrixFree<dim, number>> mg_level_data;
@@ -257,7 +257,7 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionJacobi<LevelMatrixType> SMOOTHER;
+  using SMOOTHER = PreconditionJacobi<LevelMatrixType>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<double>>
index d58cbb863a4e92a448a15b533bc234f7e07aab9f..711a5885ba7a6952de8c06535f1c9d151c5c5171 100644 (file)
@@ -72,8 +72,8 @@ template <int dim,
 class BlockLaplace : public Subscriptor
 {
 public:
-  typedef typename BlockVectorType::value_type value_type;
-  typedef typename BlockVectorType::size_type  size_type;
+  using value_type = typename BlockVectorType::value_type;
+  using size_type  = typename BlockVectorType::size_type;
 
   BlockLaplace()
     : Subscriptor()
@@ -322,12 +322,12 @@ do_test(const std::vector<const DoFHandler<dim> *> &dof)
     }
 
   // set up multigrid in analogy to step-37
-  typedef BlockLaplace<dim,
-                       fe_degree_1,
-                       fe_degree_2,
-                       n_q_points_1d,
-                       LinearAlgebra::distributed::BlockVector<number>>
-    LevelMatrixType;
+  using LevelMatrixType =
+    BlockLaplace<dim,
+                 fe_degree_1,
+                 fe_degree_2,
+                 n_q_points_1d,
+                 LinearAlgebra::distributed::BlockVector<number>>;
 
   MGLevelObject<LevelMatrixType>         mg_matrices;
   MGLevelObject<MatrixFree<dim, number>> mg_level_data;
@@ -383,7 +383,7 @@ do_test(const std::vector<const DoFHandler<dim> *> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionJacobi<LevelMatrixType> SMOOTHER;
+  using SMOOTHER = PreconditionJacobi<LevelMatrixType>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::BlockVector<number>>
index 103c2148559c67fd039fe7e802a8e246a17a112b..04e0c5427dd40a44e9ba67ef29ab1a72034c5238 100644 (file)
@@ -327,9 +327,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index cd7f36afdcec019acaea91f48c7769636fccf1c3..36dc78a95a5023bf4016c8a4f2ea9fcb1c5b96a4 100644 (file)
@@ -60,7 +60,7 @@ template <int dim,
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
@@ -365,8 +365,8 @@ do_test(const DoFHandler<dim> &dof)
   in = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim, fe_degree, n_q_points_1d, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -388,9 +388,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 8943074e6818272d55dfb8d47c57c4d12a159553..b9b4593be5e401b953a76138a73787423e2d44a5 100644 (file)
@@ -56,7 +56,7 @@ template <int dim,
 class LaplaceOperator : public Subscriptor
 {
 public:
-  typedef number value_type;
+  using value_type = number;
 
   LaplaceOperator(){};
 
@@ -361,8 +361,8 @@ do_test(const DoFHandler<dim> &dof)
   in = 1.;
 
   // set up multigrid in analogy to step-37
-  typedef LaplaceOperator<dim, fe_degree, n_q_points_1d, number>
-    LevelMatrixType;
+  using LevelMatrixType =
+    LaplaceOperator<dim, fe_degree, n_q_points_1d, number>;
 
   MGLevelObject<LevelMatrixType> mg_matrices;
   mg_matrices.resize(0, dof.get_triangulation().n_global_levels() - 1);
@@ -384,9 +384,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 31f4362ca9e8ea5ec313a8d33f2774ea7119d6f1..3451ed427ee733f3f61bf0f5e9635e39d84d0669 100644 (file)
@@ -138,13 +138,12 @@ do_test(const DoFHandler<dim> &dof)
   mg_constrained_dofs.initialize(dof);
   mg_constrained_dofs.make_zero_boundary_constraints(dof, {0});
 
-  typedef MatrixFreeOperators::LaplaceOperator<
+  using LevelMatrixType = MatrixFreeOperators::LaplaceOperator<
     dim,
     fe_degree,
     n_q_points_1d,
     1,
-    LinearAlgebra::distributed::Vector<number>>
-    LevelMatrixType;
+    LinearAlgebra::distributed::Vector<number>>;
 
   MGLevelObject<LevelMatrixType>                          mg_matrices;
   MGLevelObject<std::shared_ptr<MatrixFree<dim, number>>> mg_level_data;
@@ -191,9 +190,9 @@ do_test(const DoFHandler<dim> &dof)
   MGCoarseIterative<LevelMatrixType, number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,
-                                LinearAlgebra::distributed::Vector<number>>
-    SMOOTHER;
+  using SMOOTHER =
+    PreconditionChebyshev<LevelMatrixType,
+                          LinearAlgebra::distributed::Vector<number>>;
   MGSmootherPrecondition<LevelMatrixType,
                          SMOOTHER,
                          LinearAlgebra::distributed::Vector<number>>
index 7bff563c64e49859f518ba30fc6aee978765269b..f173f5c2e00c75cbb0f4a39c61ed5f5170fad554 100644 (file)
@@ -48,7 +48,7 @@ template <int dim, int fe_degree>
 void
 test()
 {
-  typedef double               number;
+  using number = double;
   const SphericalManifold<dim> manifold;
   Triangulation<dim>           tria;
   GridGenerator::hyper_ball(tria);
@@ -90,7 +90,7 @@ test()
                           mf_data.get_quadrature(),
                           update_quadrature_points);
 
-  typedef VectorizedArray<double> vector_t;
+  using vector_t = VectorizedArray<double>;
   for (unsigned int cell = 0; cell < n_cells; ++cell)
     {
       fe_eval.reinit(cell);
index e1c83a5b852c085e5499a4a5aac243ee04505088..52595d375d2581d18486d49129e375155abf9df4 100644 (file)
@@ -376,9 +376,9 @@ namespace Step37
     void
     output_results(const unsigned int cycle) const;
 
-    typedef LaplaceOperator<dim, degree_finite_element, double>
-                                                               SystemMatrixType;
-    typedef LaplaceOperator<dim, degree_finite_element, float> LevelMatrixType;
+    using SystemMatrixType =
+      LaplaceOperator<dim, degree_finite_element, double>;
+    using LevelMatrixType = LaplaceOperator<dim, degree_finite_element, float>;
 
     Triangulation<dim>        triangulation;
     FE_Q<dim>                 fe;
@@ -578,7 +578,7 @@ namespace Step37
     MGCoarseGridHouseholder<float, Vector<double>> mg_coarse;
     mg_coarse.initialize(coarse_matrix);
 
-    typedef PreconditionChebyshev<LevelMatrixType, Vector<double>> SMOOTHER;
+    using SMOOTHER = PreconditionChebyshev<LevelMatrixType, Vector<double>>;
     MGSmootherPrecondition<LevelMatrixType, SMOOTHER, Vector<double>>
       mg_smoother;
 
index fd119f2df3e27192a59d474334011b5084f0c3e0..2da582f0fd30547f41694ab336056cb2decdf614 100644 (file)
@@ -506,7 +506,7 @@ namespace StokesClass
     const LinearAlgebra::distributed::BlockVector<number> &src,
     const std::pair<unsigned int, unsigned int> &          cell_range) const
   {
-    typedef VectorizedArray<number>                          vector_t;
+    using vector_t = VectorizedArray<number>;
     FEEvaluation<dim, degree_v, degree_v + 1, dim, number>   velocity(data, 0);
     FEEvaluation<dim, degree_v - 1, degree_v + 1, 1, number> pressure(data, 1);
 
@@ -934,12 +934,12 @@ namespace StokesClass
     void
     solve();
 
-    typedef LinearAlgebra::distributed::Vector<double>      vector_t;
-    typedef LinearAlgebra::distributed::BlockVector<double> block_vector_t;
+    using vector_t       = LinearAlgebra::distributed::Vector<double>;
+    using block_vector_t = LinearAlgebra::distributed::BlockVector<double>;
 
-    typedef StokesOperator<dim, velocity_degree, double> StokesMatrixType;
-    typedef MassMatrixOperator<dim, velocity_degree - 1, double> MassMatrixType;
-    typedef ABlockOperator<dim, velocity_degree, double> LevelMatrixType;
+    using StokesMatrixType = StokesOperator<dim, velocity_degree, double>;
+    using MassMatrixType = MassMatrixOperator<dim, velocity_degree - 1, double>;
+    using LevelMatrixType = ABlockOperator<dim, velocity_degree, double>;
 
     unsigned int degree_u;
 
@@ -1270,7 +1270,7 @@ namespace StokesClass
                                        false,
                                        false);
 
-    typedef MGTransferMatrixFree<dim, double> Transfer;
+    using Transfer = MGTransferMatrixFree<dim, double>;
 
     Transfer mg_transfer(mg_constrained_dofs);
     mg_transfer.initialize_constraints(mg_constrained_dofs);
@@ -1288,9 +1288,9 @@ namespace StokesClass
       mg_coarse;
     mg_coarse.initialize(coarse_solver, coarse_matrix, coarse_prec_identity);
 
-    typedef PreconditionChebyshev<LevelMatrixType, vector_t> SmootherType;
-    mg::SmootherRelaxation<SmootherType, vector_t>           mg_smoother;
-    MGLevelObject<typename SmootherType::AdditionalData>     smoother_data;
+    using SmootherType = PreconditionChebyshev<LevelMatrixType, vector_t>;
+    mg::SmootherRelaxation<SmootherType, vector_t>       mg_smoother;
+    MGLevelObject<typename SmootherType::AdditionalData> smoother_data;
     smoother_data.resize(0, triangulation.n_global_levels() - 1);
     for (unsigned int level = 0; level < triangulation.n_global_levels();
          ++level)
@@ -1331,16 +1331,16 @@ namespace StokesClass
                                                    mg,
                                                    mg_transfer);
 
-    typedef PreconditionChebyshev<MassMatrixType, vector_t> MassPrec;
-    MassPrec                                                prec_S;
-    typename MassPrec::AdditionalData                       prec_S_data;
+    using MassPrec = PreconditionChebyshev<MassMatrixType, vector_t>;
+    MassPrec                          prec_S;
+    typename MassPrec::AdditionalData prec_S_data;
     prec_S_data.smoothing_range     = 1e-3;
     prec_S_data.degree              = numbers::invalid_unsigned_int;
     prec_S_data.eig_cg_n_iterations = mass_matrix.m();
     prec_S_data.preconditioner      = mass_matrix.get_matrix_diagonal_inverse();
     prec_S.initialize(mass_matrix, prec_S_data);
 
-    typedef PreconditionMG<dim, vector_t, Transfer> A_prec_type;
+    using A_prec_type = PreconditionMG<dim, vector_t, Transfer>;
 
     // create a cheap preconditioner that consists of only a single V-cycle
     const StokesSolver::BlockSchurPreconditioner<StokesMatrixType,
index 2b6c65deda173914f4d5cc6edbdfe5d8d21e7a43..250dedb4340f2eff8a931eb6a2dc4831e1f1f155 100644 (file)
@@ -51,7 +51,7 @@ test()
   auto cell = tria.begin_active();
   auto endc = tria.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
 
 
index 58397a342759e0985b7b881cd423d76fc86349ca..1de3240eee5f3883d5ee09cdf5ad315feacd6b52 100644 (file)
@@ -53,7 +53,7 @@ test()
   auto cell = tria.begin_active();
   auto endc = tria.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
 
 
index 035ea561ec92098ad71b265aac5aa11aa49fad37..43735d6d97b7d04b1153ba1125fb568db4aa2efd 100644 (file)
@@ -53,7 +53,7 @@ test()
   auto cell = tria.begin_active();
   auto endc = tria.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
 
 
index 464a1b80fe953cf930bffce158d9c85a98669c2d..988651a03f7311231031e7c462926f1c6cfa603d 100644 (file)
@@ -77,7 +77,7 @@ test()
   auto cell = dofh.begin_mg();
   auto endc = dofh.end_mg();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   auto cell_worker = [](const Iterator &cell, ScratchData &s, CopyData &c) {
     deallog << "Cell worker on : " << cell->id()
index ec683c0bb3f1605efa564dbd06271632eb27e109..f721a9de1da75143bff0338e23456fbec829df2f 100644 (file)
@@ -67,7 +67,7 @@ test()
   auto cell = tria.begin_active();
   auto endc = tria.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   auto cell_worker = [](const Iterator &cell, ScratchData &s, CopyData &c) {
     deallog << "Cell worker on : " << cell << " ghost? " << cell->is_ghost()
index 04ffe1f12ab3dab3b9b60b671d491fdd47675c05..0560785e8f4bddbeec4504a38f48eabbd9d392eb 100644 (file)
@@ -64,7 +64,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   auto measures = std::make_tuple(0.0, 0.0, 0.0);
 
index 54ccb3244bf8d4fbd9436edef2ba4ce07331a711..cafbdf7469c94c3aff9b08cba54301649e2f41a1 100644 (file)
@@ -108,7 +108,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   auto cell_worker =
     [&rhs_function](const Iterator &cell, ScratchData &s, CopyData &c) {
index b9f4805390f657917f202d2abcb1d31e14cbdd77..2e69e5acee54f5a35357ab2f6525162fa51a7b93 100644 (file)
@@ -108,7 +108,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   auto cell_worker =
     [&rhs_function](const Iterator &cell, ScratchData &s, CopyData &c) {
index 7a58ddbb598d476a2db4d3b09a4f571e5a6881bb..d59775a82c03f5089d32b34f52903dee3ac0236b 100644 (file)
@@ -89,7 +89,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
 
   auto cell_integrator = [&H1_norm, &solution, &scalar](const Iterator &cell,
index fd5166597f17a5e44e66df03a43e367f14f66816..aa8a8eadad7f4050db7bd265932a5afcaa97ae5d 100644 (file)
@@ -54,8 +54,8 @@
 
 using namespace MeshWorker;
 
-typedef Sacado::Fad::DFad<double>  Sdouble;
-typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+using Sdouble  = Sacado::Fad::DFad<double>;
+using SSdouble = Sacado::Fad::DFad<Sdouble>;
 
 template <int dim, int spacedim>
 void
@@ -112,7 +112,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   FEValuesExtractors::Scalar scalar(0);
 
index 936dc1c70ef8c2f6ba914c2a08fa5cfd04d1e18f..5d3924a0e60a52d6d5ed2ad90dd9e840e59b8ccd 100644 (file)
@@ -55,8 +55,8 @@
 
 using namespace MeshWorker;
 
-typedef Sacado::Fad::DFad<double>  Sdouble;
-typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+using Sdouble  = Sacado::Fad::DFad<double>;
+using SSdouble = Sacado::Fad::DFad<Sdouble>;
 
 template <int dim, int spacedim>
 void
@@ -113,7 +113,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   FEValuesExtractors::Scalar scalar(0);
 
index 6456c5178082dcf5b1c63f1a99284705a513dd9f..83bc7199ec51e46b803f53cc3445e50f3a423b4e 100644 (file)
@@ -55,9 +55,9 @@
 
 using namespace MeshWorker;
 
-typedef Sacado::Fad::DFad<double>   Sdouble;
-typedef Sacado::Fad::DFad<Sdouble>  SSdouble;
-typedef Sacado::Rad::ADvar<Sdouble> RSdouble;
+using Sdouble  = Sacado::Fad::DFad<double>;
+using SSdouble = Sacado::Fad::DFad<Sdouble>;
+using RSdouble = Sacado::Rad::ADvar<Sdouble>;
 
 template <int dim, int spacedim>
 void
@@ -114,7 +114,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   FEValuesExtractors::Scalar scalar(0);
 
index c78a66a22ef8d13a8abab260d3e4e698e056f7b5..5e72e85d0897d0959be0eaf72c75836407138dc1 100644 (file)
@@ -102,7 +102,7 @@ test()
   auto cell = dh.begin_active();
   auto endc = dh.end();
 
-  typedef decltype(cell) Iterator;
+  using Iterator = decltype(cell);
 
   struct CopyDataFace
   {
index 2e4584a373e274e3e7c90ef1f6174b35edf8fcbf..6d4e750fe7c4b5b297ddee08e167760b5970e6d4 100644 (file)
@@ -220,7 +220,7 @@ namespace Step11
   void
   LaplaceProblem<dim>::assemble_and_solve()
   {
-    typedef decltype(dof_handler.begin_active()) Iterator;
+    using Iterator = decltype(dof_handler.begin_active());
 
     auto cell_worker = [](const Iterator &  cell,
                           ScratchData<dim> &scratch_data,
index 423130e986fff224ae24bc6d6225357b9418abd9..cbdd34ae39c69023889f646514623351a0d966d2 100644 (file)
@@ -141,8 +141,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;
 
@@ -461,7 +461,7 @@ namespace Step50
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-    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 aafbee017645fea3ed9d5ec4c811ae262dc043ab..75df9f61826da598e0666535227e888df370ab79 100644 (file)
@@ -66,7 +66,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
index 894ad6300f4a05600124c128ae3ff57fc764a03f..fabe35d22165271cd30959bf199689135c0b164b 100644 (file)
@@ -34,7 +34,7 @@ template <int dim>
 class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index 7e8571e9b218ed285b823ea38048ad32014498b5..ad9e7f83534eda5551c9b306fcf76cab441683ee 100644 (file)
@@ -34,7 +34,7 @@ template <int dim>
 class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index 123ecbb4cb2dcfef699e1dc1c2067676199ec8c7..9eae47eea682be7ef786e08ac31c5e236655366c 100644 (file)
@@ -34,7 +34,7 @@ template <int dim>
 class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index b7dec8c2677d3599c4397c75acc2462907ef570d..6c292c5258cf6ffda8d6f6ca12b05fc349d8a4e0 100644 (file)
@@ -35,7 +35,7 @@ template <int dim>
 class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index 822777d806080a27c2cf142b421195189b1237c6..f83880d44e188395b08044f94079316037148281 100644 (file)
@@ -35,7 +35,7 @@ template <int dim>
 class myIntegrator : public dealii::MeshWorker::LocalIntegrator<dim>
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index abb8892987c2ae8eb0d51b577826b237e514e478..64992084e024244bbe9f3e95d5377d04a7e27d2a 100644 (file)
@@ -50,7 +50,7 @@ template <int dim>
 class Local : public Subscriptor
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   void
   cell(MeshWorker::DoFInfo<dim> &dinfo, CellInfo &info) const;
index abf722e9207a44506bb5f1ac187d62ffbd636f7e..29e4e7318cc3480e1dc1414b737e14d23385ab64 100644 (file)
@@ -92,8 +92,8 @@ namespace Step50
     FE_Q<dim>                                 fe;
     DoFHandler<dim>                           mg_dof_handler;
 
-    typedef TrilinosWrappers::SparseMatrix matrix_t;
-    typedef TrilinosWrappers::MPI::Vector  vector_t;
+    using matrix_t = TrilinosWrappers::SparseMatrix;
+    using vector_t = TrilinosWrappers::MPI::Vector;
 
     matrix_t system_matrix;
 
@@ -416,7 +416,7 @@ namespace Step50
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-    typedef TrilinosWrappers::PreconditionJacobi         Smoother;
+    using Smoother = TrilinosWrappers::PreconditionJacobi;
     MGSmootherPrecondition<matrix_t, Smoother, vector_t> mg_smoother;
     mg_smoother.initialize(mg_matrices);
     mg_smoother.set_steps(2);
index 07d1818050cd652c6bf8c8d8bc62c6ca3f56e0e7..2709bf27d300b11cbcb0472c5569972257fa31bf 100644 (file)
@@ -92,8 +92,8 @@ namespace Step50
     FE_Q<dim>                                 fe;
     DoFHandler<dim>                           mg_dof_handler;
 
-    typedef TrilinosWrappers::SparseMatrix matrix_t;
-    typedef TrilinosWrappers::MPI::Vector  vector_t;
+    using matrix_t = TrilinosWrappers::SparseMatrix;
+    using vector_t = TrilinosWrappers::MPI::Vector;
 
     matrix_t system_matrix;
 
@@ -403,7 +403,7 @@ namespace Step50
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-    typedef TrilinosWrappers::PreconditionJacobi         Smoother;
+    using Smoother = TrilinosWrappers::PreconditionJacobi;
     MGSmootherPrecondition<matrix_t, Smoother, vector_t> mg_smoother;
     mg_smoother.initialize(mg_matrices);
     mg_smoother.set_steps(2);
index 9f118285659d6e0d7486b872e3f32d614b887ba6..3dfb3cea7d653a189eea8b0805505aa2ba8cf649 100644 (file)
@@ -49,7 +49,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n_blocks = 5)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 7ab286e997dcaa43fa4269c3bc996120908c01dc..a3ebaeb728ce5f160e774b2fbe630f09d4198600 100644 (file)
@@ -51,7 +51,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n_blocks = 5)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 82d87269eda6c380962b5cb836d4a2f3643fa829..e40d9e2cb28326a1c2c9be46c3bba4c201c066c7 100644 (file)
@@ -49,7 +49,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n_blocks = 5)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index fced3da188e46ac67d17e77ed27da6c9a0e9bc20..9e0598b50cc722de8e2e192d3f9d0217acea7e71 100644 (file)
@@ -49,7 +49,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n_blocks = 5)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 4a2150142ccd9f910dfe85abf117c06413973b61..9addd761eb72dfa61efac178da0eff10d2828b1b 100644 (file)
@@ -52,7 +52,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n_blocks = 5)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index e2a254fd7a0d60b7fff24d2115bb84a5a2894f5e..c00a34ce830caed7632343b4651454aaaa81e227 100644 (file)
@@ -48,7 +48,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n_blocks = 5)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 606e879c654bce3df9b8100f756ebd451436c7d3..a14f01697273a9f57d4ea8b3579c9f7e827974aa 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n_blocks = 5)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index 749cc527b235a1595abf492b743b88ff0f43706f..546607d8f0d63301e5999b8dec49c4454ac45a88 100644 (file)
@@ -50,7 +50,7 @@ template <int dim, int fe_degree>
 void
 test(const unsigned int n = 5, const unsigned int m = 3)
 {
-  typedef double number;
+  using number = double;
 
   parallel::distributed::Triangulation<dim> tria(MPI_COMM_WORLD);
   GridGenerator::hyper_cube(tria);
index e6051b37f87e212637abca7d1629a4404b57ed99..8a0bd78486d156005ab05f70f492b4e9cd74a42a 100644 (file)
 template <int dim>
 struct periodicity_tests
 {
-  typedef TriaIterator<CellAccessor<dim>> cell_iterator;
-  typedef
-    typename Triangulation<dim>::active_cell_iterator active_cell_iterator;
+  using cell_iterator = TriaIterator<CellAccessor<dim>>;
+  using active_cell_iterator =
+    typename Triangulation<dim>::active_cell_iterator;
   periodicity_tests();
 
   unsigned                                  refn_cycle;
@@ -230,9 +230,9 @@ template <int dim>
 void
 periodicity_tests<dim>::check_periodicity()
 {
-  typedef std::pair<cell_iterator, unsigned> cell_face_pair;
-  typedef typename std::map<cell_face_pair, cell_face_pair>::iterator
-    cell_face_map_it;
+  using cell_face_pair = std::pair<cell_iterator, unsigned>;
+  using cell_face_map_it =
+    typename std::map<cell_face_pair, cell_face_pair>::iterator;
 
   for (int rank_i = 0; rank_i < comm_size; ++rank_i)
     {
index b44a967ca79dfe0dea6e6af2cae0283770bdc138..9c09fd236c7cae88d18c7b151864e4184244be5a 100644 (file)
@@ -258,8 +258,8 @@ check(const unsigned int orientation, bool reverse)
 
   triangulation.execute_coarsening_and_refinement();
 
-  typedef std::pair<typename Triangulation<dim>::cell_iterator, unsigned int>
-    CellFace;
+  using CellFace =
+    std::pair<typename Triangulation<dim>::cell_iterator, unsigned int>;
   const typename std::map<CellFace, std::pair<CellFace, std::bitset<3>>>
     &face_map = triangulation.get_periodic_face_map();
   typename std::map<CellFace,
index 623fc01e6a0065f50b9051099fdf9ad59493b383..580a8e64b0772775e80e9d6bf3f7bea6c662b757 100644 (file)
@@ -111,23 +111,21 @@ namespace Step37
 
     AffineConstraints<double> constraints;
     AffineConstraints<double> non_homogeneous_constraints;
-    typedef MatrixFreeOperators::LaplaceOperator<
+    using SystemMatrixType = MatrixFreeOperators::LaplaceOperator<
       dim,
       degree_finite_element,
       degree_finite_element + 1,
       1,
-      LinearAlgebra::distributed::Vector<double>>
-                     SystemMatrixType;
+      LinearAlgebra::distributed::Vector<double>>;
     SystemMatrixType system_matrix;
 
     MGConstrainedDoFs mg_constrained_dofs;
-    typedef MatrixFreeOperators::LaplaceOperator<
+    using LevelMatrixType = MatrixFreeOperators::LaplaceOperator<
       dim,
       degree_finite_element,
       degree_finite_element + 1,
       1,
-      LinearAlgebra::distributed::Vector<float>>
-                                   LevelMatrixType;
+      LinearAlgebra::distributed::Vector<float>>;
     MGLevelObject<LevelMatrixType> mg_matrices;
 
     LinearAlgebra::distributed::Vector<double> solution;
@@ -378,9 +376,9 @@ namespace Step37
     MGTransferMatrixFree<dim, float> mg_transfer(mg_constrained_dofs);
     mg_transfer.build(dof_handler);
 
-    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 5f1773aec619e0b727d9af6b49816225a604d7ce..9f325e424cbf0e9efe3386441b0de95fef4a898a 100644 (file)
@@ -395,7 +395,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
@@ -641,10 +641,9 @@ namespace Step39
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, identity);
 
-    typedef RelaxationBlockJacobi<TrilinosWrappers::SparseMatrix,
-                                  double,
-                                  TrilinosWrappers::MPI::Vector>
-      Smoother;
+    using Smoother = RelaxationBlockJacobi<TrilinosWrappers::SparseMatrix,
+                                           double,
+                                           TrilinosWrappers::MPI::Vector>;
 
     MGLevelObject<typename Smoother::AdditionalData> smoother_data;
     smoother_data.resize(0, triangulation.n_levels() - 1);
index f7a279e7987f9fad66eb3315f637fdc121739712..8466dd105fe9af3eccebd51190401aecc00e4d54 100644 (file)
@@ -396,7 +396,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
@@ -642,7 +642,7 @@ namespace Step39
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, identity);
 
-    typedef TrilinosWrappers::PreconditionJacobi Smoother;
+    using Smoother = TrilinosWrappers::PreconditionJacobi;
     MGSmootherPrecondition<TrilinosWrappers::SparseMatrix,
                            Smoother,
                            TrilinosWrappers::MPI::Vector>
index f4d44bb1c4de5527028757fd433283eeb9f54e5b..4abeb902493e721071d3f7d3962408dbad1bb939 100644 (file)
@@ -62,7 +62,7 @@
 #include "../tests.h"
 
 
-typedef parallel::distributed::Triangulation<2, 3>::cell_iterator cell_iterator;
+using cell_iterator = parallel::distributed::Triangulation<2, 3>::cell_iterator;
 DeclException1(ExcMissingCell,
                cell_iterator,
                << "Trying to find cell " << arg1
index a782ac7072d03d3ec71ba7ebef991f3041b506f1..d4c3836cca56bab373858ebecb39c4940263a700 100644 (file)
@@ -109,7 +109,7 @@ test()
   signal_counter_clear                   = 0;
   signal_counter_any_change              = 0;
 
-  typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
+  using TriaType = parallel::distributed::Triangulation<dim, spacedim>;
 
   {
     const std::string prefix = Utilities::int_to_string(dim, 1) + "d-" +
index 628cc08e4bf1393b2fb0d7cbec3e3bc474e206f6..358b21283643a8718311d8b8b217add96d99c5d4 100644 (file)
@@ -86,7 +86,7 @@ template <int dim, int spacedim>
 void
 test()
 {
-  typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
+  using TriaType = parallel::distributed::Triangulation<dim, spacedim>;
 
   {
     const std::string prefix = Utilities::int_to_string(dim, 1) + "d-" +
index a642b89171d2aa03f9c2759046e73a26a7cf31f4..67870372ef2697e8aa527edbd407f3b64f78ab6d 100644 (file)
@@ -89,7 +89,7 @@ template <int dim, int spacedim>
 void
 test()
 {
-  typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
+  using TriaType = parallel::distributed::Triangulation<dim, spacedim>;
 
   {
     const std::string prefix = Utilities::int_to_string(dim, 1) + "d-" +
index 997480de38cc282ec6f47ac207458a31a3f8d4b6..d5ef15ea436b810c0529ee2f59f66ed4c97eea7c 100644 (file)
@@ -90,7 +90,7 @@ template <int dim, int spacedim>
 void
 test()
 {
-  typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
+  using TriaType = parallel::distributed::Triangulation<dim, spacedim>;
 
   {
     const std::string prefix = Utilities::int_to_string(dim, 1) + "d-" +
index 69547740820203f90856be9671a6ce284629f177..dc94d30441ac43c4289c5ee9be732ed50dfbe7b9 100644 (file)
@@ -90,7 +90,7 @@ template <int dim, int spacedim>
 void
 test()
 {
-  typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
+  using TriaType = parallel::distributed::Triangulation<dim, spacedim>;
 
   {
     const std::string prefix = Utilities::int_to_string(dim, 1) + "d-" +
index 53667f557f858e17b82e8ad70969752111293227..f0833062c80b25205f2549ab8eb1e45eb8033892 100644 (file)
@@ -89,7 +89,7 @@ template <int dim, int spacedim>
 void
 test()
 {
-  typedef parallel::distributed::Triangulation<dim, spacedim> TriaType;
+  using TriaType = parallel::distributed::Triangulation<dim, spacedim>;
 
   {
     const std::string prefix = Utilities::int_to_string(dim, 1) + "d-" +
index aa0d18af5c274ccf154eb5431495c9b1497dd0dd..c3cfab7fe6e8bdfecd8b30f3b23588bae6625892 100644 (file)
@@ -33,7 +33,7 @@
 
 
 #define N 3
-typedef Vector<double> VectorType;
+using VectorType = Vector<double>;
 
 class MGAll : public MGSmootherBase<VectorType>,
               public MGTransferBase<VectorType>,
index 02bd6b848668281149ee86410305846dec526420..6bba6dc7bb5a6b972aea916bdac231426dcc0cfe 100644 (file)
@@ -82,8 +82,8 @@ namespace Step50
     run();
 
   private:
-    typedef LA::MPI::SparseMatrix matrix_t;
-    typedef LA::MPI::Vector       vector_t;
+    using matrix_t = LA::MPI::SparseMatrix;
+    using vector_t = LA::MPI::Vector;
 
     void
     setup_system();
@@ -391,7 +391,7 @@ namespace Step50
     MGTransferPrebuilt<vector_t> mg_transfer(mg_constrained_dofs);
     mg_transfer.build(mg_dof_handler);
 
-    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 b344975e965cd1cde9e038eb3ab958738c9591ed..73b5dafb5618c8547604dc4166546aa6c4371568 100644 (file)
@@ -82,8 +82,8 @@ namespace Step50
     run();
 
   private:
-    typedef LA::MPI::SparseMatrix matrix_t;
-    typedef LA::MPI::Vector       vector_t;
+    using matrix_t = LA::MPI::SparseMatrix;
+    using vector_t = LA::MPI::Vector;
 
     void
     setup_system();
@@ -462,7 +462,7 @@ namespace Step50
     MGTransferPrebuilt<vector_t> mg_transfer(mg_constrained_dofs);
     mg_transfer.build(mg_dof_handler);
 
-    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 c15107f1d6ac5abbe3a9359955911c482a822435..29eb33c9368cd4624df10e4d433957dccbf5c642 100644 (file)
@@ -371,7 +371,7 @@ LaplaceProblem<dim>::test()
   MGCoarseGridHouseholder<double, Vector<double>> mg_coarse_renumbered;
   mg_coarse_renumbered.initialize(coarse_matrix_renumbered);
 
-  typedef PreconditionIdentity RELAXATION;
+  using RELAXATION = PreconditionIdentity;
   MGSmootherPrecondition<SparseMatrix<double>, RELAXATION, Vector<double>>
     mg_smoother;
 
index 6c1cc2a02e5cf8d46a4c99394a275802ac3eaef5..64a1e034b9fa17e07f689135cef5f93dfe59347d 100644 (file)
@@ -179,7 +179,7 @@ template <int dim>
 class LaplaceProblem
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   LaplaceProblem(const unsigned int deg);
   void
index 9bc0e7d4598f92e1eb6601c297b42b2f9e5bddf0..93e993a25e53ee6bde00b8a4164fdcf80b26a964 100644 (file)
@@ -226,7 +226,7 @@ template <int dim>
 class LaplaceProblem
 {
 public:
-  typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+  using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
   LaplaceProblem(const unsigned int deg);
   void
index 1ccc1c8c8f0e58a3e1a6173b44232157472137a0..c23bbc4eda4c580fd737e8e4687b8c1893857f85 100644 (file)
@@ -481,7 +481,7 @@ LaplaceProblem<dim>::solve()
   MGCoarseGridHouseholder<> coarse_grid_solver;
   coarse_grid_solver.initialize(coarse_matrix);
 
-  typedef PreconditionSOR<SparseMatrix<double>> Smoother;
+  using Smoother = PreconditionSOR<SparseMatrix<double>>;
   MGSmootherRelaxation<SparseMatrix<double>, Smoother, Vector<double>>
     mg_smoother;
   mg_smoother.initialize(mg_matrices);
index 8ee966bf5c9abb9a1f4d6872f68e108451aa193b..557dcaf910d3dff86f486f748205e0db3055d3bd 100644 (file)
@@ -374,8 +374,8 @@ LaplaceProblem<dim>::solve()
   MGCoarseGridHouseholder<> coarse_grid_solver;
   coarse_grid_solver.initialize(coarse_matrix);
 
-  typedef PreconditionSOR<SparseMatrix<double>> Smoother;
-  GrowingVectorMemory<>                         vector_memory;
+  using Smoother = PreconditionSOR<SparseMatrix<double>>;
+  GrowingVectorMemory<> vector_memory;
   MGSmootherRelaxation<SparseMatrix<double>, Smoother, Vector<double>>
     mg_smoother;
   mg_smoother.initialize(mg_matrices);
index 832ba2c1a41df16ca6d7cd9a17e7617a987402a3..cbb32979fe83e7a6bebcefaeed57743eee668d05 100644 (file)
@@ -390,9 +390,9 @@ LaplaceProblem<dim>::solve()
   deallog << "   Size of coarse grid matrix: " << mg_matrices[min_level].m()
           << std::endl;
 
-  typedef PreconditionChebyshev<SparseMatrix<double>,
-                                LinearAlgebra::distributed::Vector<double>>
-                                                                  Smoother;
+  using Smoother =
+    PreconditionChebyshev<SparseMatrix<double>,
+                          LinearAlgebra::distributed::Vector<double>>;
   GrowingVectorMemory<LinearAlgebra::distributed::Vector<double>> vector_memory;
   MGSmootherPrecondition<SparseMatrix<double>,
                          Smoother,
index 9319d1b6876840fc871d5645e22359d7261af24a..3e8179a45061fc8bb59c86db30d23340bf8f6038 100644 (file)
@@ -391,9 +391,9 @@ LaplaceProblem<dim>::solve()
   deallog << "   Size of coarse grid matrix: " << mg_matrices[min_level].m()
           << std::endl;
 
-  typedef PreconditionChebyshev<SparseMatrix<double>,
-                                LinearAlgebra::distributed::Vector<double>>
-                                                                  Smoother;
+  using Smoother =
+    PreconditionChebyshev<SparseMatrix<double>,
+                          LinearAlgebra::distributed::Vector<double>>;
   GrowingVectorMemory<LinearAlgebra::distributed::Vector<double>> vector_memory;
   MGSmootherPrecondition<SparseMatrix<double>,
                          Smoother,
index 6f4ccece2e25ef1969547ac5eeab31cdededd1fe..0cc688a200eb1f71e0f6531a09f45fcde10ef241 100644 (file)
@@ -391,9 +391,9 @@ LaplaceProblem<dim>::solve()
   deallog << "   Size of coarse grid matrix: " << mg_matrices[min_level].m()
           << std::endl;
 
-  typedef PreconditionChebyshev<SparseMatrix<double>,
-                                LinearAlgebra::distributed::Vector<double>>
-                                                                  Smoother;
+  using Smoother =
+    PreconditionChebyshev<SparseMatrix<double>,
+                          LinearAlgebra::distributed::Vector<double>>;
   GrowingVectorMemory<LinearAlgebra::distributed::Vector<double>> vector_memory;
   MGSmootherPrecondition<SparseMatrix<double>,
                          Smoother,
index e39c49c16592e837d93b6e132372aa7a23e89ada..03e9ca02dfe5a3d802e8d1051156f54153b02a28 100644 (file)
@@ -455,7 +455,7 @@ LaplaceProblem<dim>::solve()
   MGCoarseGridHouseholder<> coarse_grid_solver;
   coarse_grid_solver.initialize(coarse_matrix);
 
-  typedef PreconditionJacobi<SparseMatrix<double>> Smoother;
+  using Smoother = PreconditionJacobi<SparseMatrix<double>>;
   MGSmootherPrecondition<SparseMatrix<double>, Smoother, Vector<double>>
     mg_smoother;
   mg_smoother.initialize(mg_matrices, typename Smoother::AdditionalData(0.678));
index 807f7e8add5138c86c6331bafca219c3a09318a6..d3b415d14e841989b05af0cc69c06190707ababe 100644 (file)
@@ -462,8 +462,8 @@ LaplaceProblem<dim>::solve()
   MGCoarseGridHouseholder<> coarse_grid_solver;
   coarse_grid_solver.initialize(coarse_matrix);
 
-  typedef PreconditionSOR<SparseMatrix<double>> Smoother;
-  GrowingVectorMemory<>                         vector_memory;
+  using Smoother = PreconditionSOR<SparseMatrix<double>>;
+  GrowingVectorMemory<> vector_memory;
   MGSmootherRelaxation<SparseMatrix<double>, Smoother, Vector<double>>
     mg_smoother;
   mg_smoother.initialize(mg_matrices);
index 8304a8f551b295087147e7c3d48c4d6220572d0d..7a8efb5ea4ccbbc0c0e46fa3e71df307bcf601ad 100644 (file)
@@ -103,8 +103,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;
 
@@ -449,7 +449,7 @@ namespace Step50
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-    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 3c3a6caad315554a5aff40c2cf73690f83058892..24759a59a3168850a79fe69f8992446f6a3bb1f4 100644 (file)
@@ -103,8 +103,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;
 
@@ -438,7 +438,7 @@ namespace Step50
     mg_transfer.build(mg_dof_handler);
 
     // pre and post 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 085f191062d4e50e3db701a8c47d4b222948a84c..b3c8670d20898421e507b13d254a2ab36084b42d 100644 (file)
@@ -103,8 +103,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;
 
@@ -449,7 +449,7 @@ namespace Step50
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-    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 cd4d0e0559845f610297c6d40d3bf2c376f09a3d..a1ed55fbf30b7a999d0eab0a83514bb1e678c945 100644 (file)
@@ -365,8 +365,8 @@ template <int dim>
 void
 LaplaceProblem<dim>::solve()
 {
-  typedef SparseMatrix<double> matrix_t;
-  typedef Vector<double>       vector_t;
+  using matrix_t = SparseMatrix<double>;
+  using vector_t = Vector<double>;
 
   MGTransferPrebuilt<vector_t> mg_transfer(mg_constrained_dofs);
   mg_transfer.build(mg_dof_handler);
@@ -382,7 +382,7 @@ LaplaceProblem<dim>::solve()
                               PreconditionIdentity>
     coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-  typedef PreconditionJacobi<matrix_t>                 Smoother;
+  using Smoother = PreconditionJacobi<matrix_t>;
   MGSmootherPrecondition<matrix_t, Smoother, vector_t> mg_smoother;
   mg_smoother.initialize(mg_matrices, Smoother::AdditionalData(0.5));
   mg_smoother.set_steps(2);
index 9b0e7ac9257a859c7eebc3675ab3662e98eac4b6..da7f0d6fa420a07bb10839951bafe0ca471996a0 100644 (file)
@@ -498,7 +498,7 @@ LaplaceProblem<dim>::solve(bool use_mw)
   MGCoarseGridHouseholder<> coarse_grid_solver;
   coarse_grid_solver.initialize(coarse_matrix);
 
-  typedef PreconditionSOR<SparseMatrix<double>> Smoother;
+  using Smoother = PreconditionSOR<SparseMatrix<double>>;
   MGSmootherRelaxation<SparseMatrix<double>, Smoother, Vector<double>>
     mg_smoother;
   mg_smoother.initialize(mg_matrices);
index 679697373fd7e9fc4017eeace53630988faf67d3..0a67e07e5e138909a9d3f9d324192ec20a596470 100644 (file)
@@ -455,8 +455,8 @@ LaplaceProblem<dim>::solve()
   MGCoarseGridHouseholder<> coarse_grid_solver;
   coarse_grid_solver.initialize(coarse_matrix);
 
-  typedef PreconditionSOR<SparseMatrix<double>> Smoother;
-  GrowingVectorMemory<>                         vector_memory;
+  using Smoother = PreconditionSOR<SparseMatrix<double>>;
+  GrowingVectorMemory<> vector_memory;
   MGSmootherRelaxation<SparseMatrix<double>, Smoother, Vector<double>>
     mg_smoother;
   mg_smoother.initialize(mg_matrices);
index aab173d8fd6c5d8e0f90bd18992f0fe418ea0adf..8238daea12a72e89c65d40d954503ba2be54520d 100644 (file)
@@ -386,7 +386,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
@@ -596,8 +596,8 @@ namespace Step39
     MGCoarseGridHouseholder<double, Vector<double>> mg_coarse;
     mg_coarse.initialize(coarse_matrix);
 
-    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 bc2032d6c547bbc80e4187a3abf7e07196d70e23..ff98a19f68e7e93048b0f473b58d815a5c15d0f3 100644 (file)
@@ -388,7 +388,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
@@ -603,8 +603,8 @@ namespace Step39
     MGCoarseGridHouseholder<double, Vector<double>> mg_coarse;
     mg_coarse.initialize(coarse_matrix);
 
-    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 f22e5c86384a6ff007efc4e79d0087a47764b1a0..39cc1abaa2c923472b6b3d9bc7f32fa5f43a3903 100644 (file)
@@ -392,7 +392,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
@@ -602,8 +602,8 @@ namespace Step39
     MGCoarseGridHouseholder<double, Vector<double>> mg_coarse;
     mg_coarse.initialize(coarse_matrix);
 
-    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 0ae498d4c9dcdf4e13dd83c3f4325e30ee55f89e..271da3b377e97d333d8e0c5c5b114a5f9b223593 100644 (file)
@@ -387,7 +387,7 @@ namespace Step39
   class InteriorPenaltyProblem
   {
   public:
-    typedef MeshWorker::IntegrationInfo<dim> CellInfo;
+    using CellInfo = MeshWorker::IntegrationInfo<dim>;
 
     InteriorPenaltyProblem(const FiniteElement<dim> &fe);
 
@@ -586,8 +586,8 @@ namespace Step39
     MGCoarseGridHouseholder<double, Vector<double>> mg_coarse;
     mg_coarse.initialize(coarse_matrix);
 
-    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 2d0b542ed4dc1f5c884f9671beb9c9de0da2967f..09652e34288a10a0d6dbd2d7a0852a3b4115ba94 100644 (file)
@@ -101,8 +101,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;
 
@@ -450,7 +450,7 @@ namespace Step50
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-    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 acd2556295e29d8e2ede6f84a963ac612c65e469..507a7890dda91babcff1d07f2ffd3c46113cad37 100644 (file)
@@ -102,8 +102,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;
 
@@ -456,7 +456,7 @@ namespace Step50
                                 PreconditionIdentity>
       coarse_grid_solver(coarse_solver, coarse_matrix, id);
 
-    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 18dcaaf26035c3a1b42a6bd0f7a6a38ef89a53ee..937e111438df03d75a8a243f6e8202b467a19817 100644 (file)
@@ -123,7 +123,7 @@ check_fe(FiniteElement<dim> &fe)
   DoFHandler<dim> dofh(tr);
   dofh.distribute_dofs(fe);
   dofh.distribute_mg_dofs();
-  typedef TrilinosWrappers::MPI::Vector vector_t;
+  using vector_t = TrilinosWrappers::MPI::Vector;
 
   MGConstrainedDoFs mg_constrained_dofs;
   mg_constrained_dofs.initialize(dofh);
index 7dd1e53f03d9ec29d6e5e22245b401dacf9a3412..f3cc28ce0f03f7305b7b9cfd2a5005b60c61e449 100644 (file)
@@ -127,7 +127,7 @@ check_fe(FiniteElement<dim> &fe)
   DoFHandler<dim> dofh(tr);
   dofh.distribute_dofs(fe);
   dofh.distribute_mg_dofs();
-  typedef TrilinosWrappers::MPI::Vector vector_t;
+  using vector_t = TrilinosWrappers::MPI::Vector;
   {}
   MGTransferPrebuilt<vector_t> transfer;
   transfer.build(dofh);
index 83f535626722865729ee625576ddd081292ea473..a1a0e17c75af8b6f1cd29356fb33cd02039c5346 100644 (file)
@@ -127,7 +127,7 @@ check_fe(FiniteElement<dim> &fe)
   DoFHandler<dim> dofh(tr);
   dofh.distribute_dofs(fe);
   dofh.distribute_mg_dofs();
-  typedef PETScWrappers::MPI::Vector vector_t;
+  using vector_t = PETScWrappers::MPI::Vector;
   {}
   MGTransferPrebuilt<vector_t> transfer;
   transfer.build(dofh);
index 40f5dc8180a9ef13f05de2399d3a8addc32a2dc2..60533824981b542a5441730a8c7556be629fb940 100644 (file)
@@ -39,7 +39,7 @@ template <typename number>
 void
 test()
 {
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
 
   // size of the problem
   const unsigned int N = 10;
index 21f625437a3f59cef7e9f4958a333af2e21af12f..d21219d3621fd4dff206220fce348a218d84aa75 100644 (file)
@@ -40,7 +40,7 @@ test()
   auto &out = deallog.get_file_stream();
   out << std::setprecision(5) << std::fixed << std::right;
 
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
 
   // size of the problem
   const unsigned int N = 20;
index 5377566fc98d9fac7c32237c69394461da4ee221..d0a3bfdedeeba0d9350466a0a4518557219ac39c 100644 (file)
@@ -62,7 +62,7 @@ test()
   auto &out = deallog.get_file_stream();
   out << std::setprecision(5) << std::fixed << std::right;
 
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
 
   // size of the problem
   const unsigned int N = 21;
index 08aa8fc7253ebbe185883496b372ba01d46f04ae..d75941f23ee70113c1f6ca716262258ea54f1835 100644 (file)
@@ -40,7 +40,7 @@ test()
   auto &out = deallog.get_file_stream();
   out << std::setprecision(5) << std::fixed << std::right;
 
-  typedef Vector<number> VectorType;
+  using VectorType = Vector<number>;
 
   // size of the problem
   const unsigned int N = 21;
index 3c962f05632f31029ed53943638b836598466c49..7376fcbbc12ca1d310b99cc1db31abdcdf91dd4d 100644 (file)
@@ -29,7 +29,7 @@ main()
 {
   initlog();
 
-  typedef std::tuple<std::string, Point<3>, unsigned int> T;
+  using T = std::tuple<std::string, Point<3>, unsigned int>;
 
   T a;
   a = Convert<T>::to_value("Ciao : 1.0, 2.0, 3.0 : 33");
index 668705b56fa91fa8d79c28f5471c496e5f41b9a7..46a30da973d0d696f8251fda12a50768a1058287 100644 (file)
@@ -30,7 +30,7 @@ main()
 {
   initlog();
 
-  typedef std::unique_ptr<FunctionParser<3>> T;
+  using T = std::unique_ptr<FunctionParser<3>>;
 
   T a;
   a = Convert<T>::to_value("x*y,y-t");
index c30a237b27169b9802c9fbef2ed6aaf656bc510e..add13a0294a86b276b1647b5d4d34162f543bff4 100644 (file)
@@ -31,7 +31,7 @@ main()
 {
   initlog();
 
-  typedef ComponentMask T;
+  using T = ComponentMask;
 
   T a;
   a = Convert<T>::to_value("true,false,true");
index ef75c6192b921f349a3f7dc416734e34f878112f..3a85bab51921df8cfadaf8370960af648351cc81 100644 (file)
@@ -32,7 +32,7 @@ main()
 {
   initlog();
 
-  typedef std::map<types::boundary_id, std::unique_ptr<FunctionParser<3>>> T;
+  using T = std::map<types::boundary_id, std::unique_ptr<FunctionParser<3>>>;
 
   T a;
   a = Convert<T>::to_value("0:x,y,z*t");
index a6e5731d86b20d4de1b22ed0aa00420118d5a4f1..ab4d89189d9b07aae985f63c1023f53c293d8b88 100644 (file)
@@ -65,7 +65,7 @@ main(int argc, char **argv)
     {
       Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
       {
-        typedef PETScWrappers::SparseMatrix::size_type size_type;
+        using size_type = PETScWrappers::SparseMatrix::size_type;
 
         std::vector<size_type> row_lengths(5, 3U);
         row_lengths.back() = 2;
index 6fe7203ec4070ac9cb13e2ed8298d44083d99088..e5df64c7f73e926f9662b705422f1d911545f5ce 100644 (file)
@@ -29,7 +29,7 @@
 void
 test(PETScWrappers::MatrixBase &m)
 {
-  typedef PETScWrappers::MatrixBase::size_type size_type;
+  using size_type = PETScWrappers::MatrixBase::size_type;
 
   Assert(m.m() != 0, ExcInternalError());
   Assert(m.n() != 0, ExcInternalError());
index 087b7c57c88893a13e016b2d4399d7153cffaef5..ab2a023e0592fe920302c08f86ab79b9dd2353a9 100644 (file)
@@ -32,7 +32,7 @@ test(PETScWrappers::MatrixBase &m)
   Assert(m.m() != 0, ExcInternalError());
   Assert(m.n() != 0, ExcInternalError());
 
-  typedef PETScWrappers::MatrixBase::size_type size_type;
+  using size_type = PETScWrappers::MatrixBase::size_type;
 
   // build a tri-diagonal pattern
   double          norm_sqr = 0;
index 9a59de20f8edaa1a144b32ff322f2fb2252e78c2..523c6d0e4d3b1a280946b1bcfca353e1c87a6e0d 100644 (file)
@@ -56,7 +56,7 @@ get_this_mpi_process()
 void
 test()
 {
-  typedef PETScWrappers::MPI::SparseMatrix::size_type size_type;
+  using size_type = PETScWrappers::MPI::SparseMatrix::size_type;
 
   // create a parallel matrix where the first
   // process has 10 rows, the second one 20,
index 8e979886c26ef915d67271670c3bcf2ba49f0845..942297f17cfe460116385774c1d0b4154c9b37f7 100644 (file)
@@ -122,7 +122,7 @@ test_scalars()
   const Vector<double>     vA = Notation::Kelvin::to_vector(A);
   const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
-  typedef typename std::decay<decltype(A)>::type InpType;
+  using InpType      = typename std::decay<decltype(A)>::type;
   const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
   const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
@@ -141,7 +141,7 @@ test_rank_0_tensors()
   const Vector<double>     vA = Notation::Kelvin::to_vector(A);
   const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
-  typedef typename std::decay<decltype(A)>::type InpType;
+  using InpType      = typename std::decay<decltype(A)>::type;
   const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
   const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
@@ -160,7 +160,7 @@ test_rank_1_tensors()
 
   const Vector<double> vA = Notation::Kelvin::to_vector(A);
 
-  typedef typename std::decay<decltype(A)>::type InpType;
+  using InpType      = typename std::decay<decltype(A)>::type;
   const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
 
   Assert((vA_conv - A).norm() < 1e-12,
@@ -179,7 +179,7 @@ test_rank_2_tensors()
     const Vector<double>     vA = Notation::Kelvin::to_vector(A);
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
@@ -197,7 +197,7 @@ test_rank_2_tensors()
     const Vector<double>     vA = Notation::Kelvin::to_vector(A);
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto vA_conv = Notation::Kelvin::to_tensor<InpType>(vA);
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
@@ -220,7 +220,7 @@ test_rank_3_tensors()
     const FullMatrix<double> mA =
       Notation::Kelvin::to_matrix<dim, Tensor<1, dim>, Tensor<2, dim>>(A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
@@ -235,7 +235,7 @@ test_rank_3_tensors()
     const FullMatrix<double> mA =
       Notation::Kelvin::to_matrix<dim, Tensor<2, dim>, Tensor<1, dim>>(A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
@@ -251,7 +251,7 @@ test_rank_3_tensors()
       Notation::Kelvin::to_matrix<dim, SymmetricTensor<2, dim>, Tensor<1, dim>>(
         A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
@@ -267,7 +267,7 @@ test_rank_3_tensors()
       Notation::Kelvin::to_matrix<dim, Tensor<1, dim>, SymmetricTensor<2, dim>>(
         A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
@@ -286,7 +286,7 @@ test_rank_4_tensors()
 
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
@@ -300,7 +300,7 @@ test_rank_4_tensors()
 
     const FullMatrix<double> mA = Notation::Kelvin::to_matrix(A);
 
-    typedef typename std::decay<decltype(A)>::type InpType;
+    using InpType      = typename std::decay<decltype(A)>::type;
     const auto mA_conv = Notation::Kelvin::to_tensor<InpType>(mA);
 
     Assert((mA_conv - A).norm() < 1e-12,
index e622df8b5f218202b14d45a2fd072aaf6430ec38..691c754912819389d523176b259e0eacc247236e 100644 (file)
@@ -129,9 +129,9 @@ test_scalars()
   Vector<double>           vB(mC.m());
   mC.vmult(vB, vA);
 
-  typedef typename std::decay<decltype(A)>::type InpVecType;
-  typedef typename std::decay<decltype(B)>::type ResVecType;
-  typedef typename std::decay<decltype(C)>::type InpMatType;
+  using InpVecType  = typename std::decay<decltype(A)>::type;
+  using ResVecType  = typename std::decay<decltype(B)>::type;
+  using InpMatType  = typename std::decay<decltype(C)>::type;
   const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
   const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
   const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -169,9 +169,9 @@ test_rank_0_tensors()
   Vector<double>           vB(mC.m());
   mC.vmult(vB, vA);
 
-  typedef typename std::decay<decltype(A)>::type InpVecType;
-  typedef typename std::decay<decltype(B)>::type ResVecType;
-  typedef typename std::decay<decltype(C)>::type InpMatType;
+  using InpVecType  = typename std::decay<decltype(A)>::type;
+  using ResVecType  = typename std::decay<decltype(B)>::type;
+  using InpMatType  = typename std::decay<decltype(C)>::type;
   const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
   const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
   const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -213,9 +213,9 @@ test_rank_1_2_tensors()
     Vector<double>           vB(mC.m());
     mC.vmult(vB, vA);
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -253,9 +253,9 @@ test_rank_1_2_tensors()
     Vector<double>           vB(mC.m());
     mC.vmult(vB, vA);
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -298,9 +298,9 @@ test_rank_2_4_tensors()
     Vector<double>           vB(mC.m());
     mC.vmult(vB, vA);
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -338,9 +338,9 @@ test_rank_2_4_tensors()
     Vector<double>           vB(mC.m());
     mC.vmult(vB, vA);
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -381,9 +381,9 @@ test_rank_2_4_tensors()
     Vector<double>           vB(mC.m());
     mC.vmult(vB, vA);
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -428,9 +428,9 @@ test_rank_3_tensors()
     Vector<double>           vB(mC.n()); // Note result size
     mC.Tvmult(vB, vA);                   // Note transpose vmult
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -472,9 +472,9 @@ test_rank_3_tensors()
     Vector<double> vB(mC.m()); // Note result size
     mC.vmult(vB, vA);          // Note transpose vmult
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -517,9 +517,9 @@ test_rank_3_tensors()
     Vector<double> vB(mC.n()); // Note result size
     mC.Tvmult(vB, vA);         // Note transpose vmult
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
@@ -562,9 +562,9 @@ test_rank_3_tensors()
     Vector<double> vB(mC.m()); // Note result size
     mC.vmult(vB, vA);          // Note transpose vmult
 
-    typedef typename std::decay<decltype(A)>::type InpVecType;
-    typedef typename std::decay<decltype(B)>::type ResVecType;
-    typedef typename std::decay<decltype(C)>::type InpMatType;
+    using InpVecType  = typename std::decay<decltype(A)>::type;
+    using ResVecType  = typename std::decay<decltype(B)>::type;
+    using InpMatType  = typename std::decay<decltype(C)>::type;
     const auto A_conv = Notation::Kelvin::to_tensor<InpVecType>(vA);
     const auto B_conv = Notation::Kelvin::to_tensor<ResVecType>(vB);
     const auto C_conv = Notation::Kelvin::to_tensor<InpMatType>(mC);
index 11acd7ab886291065b4879deb17cd391b09c86ac..59c34e72fdd1154276ea9f56814ea8224c4b4030 100644 (file)
@@ -72,7 +72,7 @@ public:
 void
 test(const double x, const double y)
 {
-  typedef double RealT;
+  using RealT = double;
 
   QuadraticObjective<RealT> quad_objective;
 
index f6e1e55e655260c697aa02a1ef67c4051d0f10a2..fab678b44dc1191d7244b1ff71e861be0134730b 100644 (file)
@@ -78,9 +78,9 @@ main()
   bfad.val() = Sacado::Fad::DFad<double>(num_deriv, 1, b);
 
   // AD typedefs
-  typedef Sacado::Fad::DFad<Sacado::Fad::DFad<double>> ADNumberType;
-  typedef typename ADNumberType::value_type            ADDerivativeType;
-  typedef typename ADNumberType::scalar_type ADScalarType; // == double
+  using ADNumberType     = Sacado::Fad::DFad<Sacado::Fad::DFad<double>>;
+  using ADDerivativeType = typename ADNumberType::value_type;
+  using ADScalarType     = typename ADNumberType::scalar_type; // == double
 
   // Compute function and derivative with AD
   const ADNumberType rfad = func(afad, bfad, cfad);
index 437696e9bed462ffdd3bf992ba63fe39e0aa7cd2..2c40f7bb57d24c696c8e7542813447f32c4270bf 100644 (file)
@@ -36,7 +36,7 @@ check()
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double> Sdouble;
+  using Sdouble = Sacado::Fad::DFad<double>;
   initlog();
 
 
index d4438293bf09f0efc9c7a0d20b4c6ad9f59d45f2..6e234f3bb8a4d07ae2e468381175ccc873ceea37 100644 (file)
@@ -36,8 +36,8 @@ check()
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double>  Sdouble;
-  typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+  using Sdouble  = Sacado::Fad::DFad<double>;
+  using SSdouble = Sacado::Fad::DFad<Sdouble>;
   initlog();
 
 
index 353783775300e76abd51ddb1a035bf1ae0d872ee..0691d5e2a069edf6fc796ebc96aec12f0cd50489 100644 (file)
@@ -36,8 +36,8 @@ check()
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double>  Sdouble;
-  typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+  using Sdouble  = Sacado::Fad::DFad<double>;
+  using SSdouble = Sacado::Fad::DFad<Sdouble>;
   initlog();
 
 
index 39dd18b22be249ca134d3a2d42ba31bf17d305e1..87fed0706cf6b520911592e41baa702051aadc5f 100644 (file)
@@ -36,8 +36,8 @@ check()
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double>  Sdouble;
-  typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+  using Sdouble  = Sacado::Fad::DFad<double>;
+  using SSdouble = Sacado::Fad::DFad<Sdouble>;
   initlog();
 
 
index 0c9019ffeb52deda2647deb3836a1680cc626459..02f4156759a8cf878b9a28a115f6f7e99aa1fba1 100644 (file)
@@ -36,8 +36,8 @@ check()
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double>  Sdouble;
-  typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+  using Sdouble  = Sacado::Fad::DFad<double>;
+  using SSdouble = Sacado::Fad::DFad<Sdouble>;
   initlog();
 
 
index f6cc4d36209974bb925d542494db3648c7715da6..cf32057dc78da03c958bc47c47aa25e00e947f84 100644 (file)
@@ -27,7 +27,7 @@
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double> Sdouble;
+  using Sdouble = Sacado::Fad::DFad<double>;
   initlog();
 
 
index b02fd1607ba4d62ff366676046115ed03984b20c..25e47a5e2f5b6e0eac5c939153369e37f530514f 100644 (file)
@@ -27,8 +27,8 @@
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double>  Sdouble;
-  typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+  using Sdouble  = Sacado::Fad::DFad<double>;
+  using SSdouble = Sacado::Fad::DFad<Sdouble>;
   initlog();
 
 
index 172b17d7e349589c5377c7d38d04af4e2e52638e..8f4ed38b3eb40dfddffbe5e10bff2e5085d1653a 100644 (file)
@@ -27,7 +27,7 @@
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double> Sdouble;
+  using Sdouble = Sacado::Fad::DFad<double>;
   initlog();
 
 
index daa725357078ea37355d935a8853751566916359..4751699970e9d75619d69378ea2627cb5cc9b001 100644 (file)
@@ -27,8 +27,8 @@
 int
 main()
 {
-  typedef Sacado::Fad::DFad<double>  Sdouble;
-  typedef Sacado::Fad::DFad<Sdouble> SSdouble;
+  using Sdouble  = Sacado::Fad::DFad<double>;
+  using SSdouble = Sacado::Fad::DFad<Sdouble>;
   initlog();
 
 
index b1df31af0ac3c25e48fb2cada498e9438369cdb7..22e3b1f5142c61414b447bd34d04bf4dae3ad9e1 100644 (file)
@@ -58,7 +58,7 @@ main()
 
   const FEValuesExtractors::Scalar extractor_sclr(0);
 
-  typedef Sacado::Fad::DFad<double>     ad_type;
+  using ad_type                              = Sacado::Fad::DFad<double>;
   DoFHandler<dim>::active_cell_iterator cell = dof_handler.begin_active();
   DoFHandler<dim>::active_cell_iterator endc = dof_handler.end();
   for (; cell != endc; ++cell)
index 279f2ee6ad1960d6e28cee42ca538f0b4b6e42eb..4f368c38b64f3ba48873b331e78b016a7f47e18c 100644 (file)
@@ -57,7 +57,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, numbers::invalid_unsigned_int);
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   ParameterHandler                             prm;
   SUNDIALS::ARKode<VectorType>::AdditionalData data;
index 8e4d395981c279d2694d9fb843101c2039f88092..02bdd523fa6a3bef21c617f669210805f30705c6 100644 (file)
@@ -57,7 +57,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, numbers::invalid_unsigned_int);
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   ParameterHandler                             prm;
   SUNDIALS::ARKode<VectorType>::AdditionalData data;
index 04116ad06ca1945e94b73b34e7879aa904591fec..3a5eb1b57f0633324d5bdc28d597f1ea40730988 100644 (file)
@@ -54,7 +54,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, numbers::invalid_unsigned_int);
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   ParameterHandler                             prm;
   SUNDIALS::ARKode<VectorType>::AdditionalData data;
index 66d37344f3c8a29e7e663ddca639495b3eca310e..ca676b4a57f806198ba6aeefc9c5be3e473aceb0 100644 (file)
@@ -54,7 +54,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, numbers::invalid_unsigned_int);
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   ParameterHandler                             prm;
   SUNDIALS::ARKode<VectorType>::AdditionalData data;
index d0f5a69810c539aded40203761b89eb31a710984..9eaa6c8ff35f2fb8dfd4b1224e8454dd648ed4e4 100644 (file)
@@ -61,7 +61,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, numbers::invalid_unsigned_int);
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   ParameterHandler                             prm;
   SUNDIALS::ARKode<VectorType>::AdditionalData data;
index 264099ce4f8d8d57652f7c1b91cf9e95dc820da3..a5b6a632ab0a4fdc7734b3c4354aa0f939650f07 100644 (file)
@@ -61,7 +61,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, numbers::invalid_unsigned_int);
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   ParameterHandler                             prm;
   SUNDIALS::ARKode<VectorType>::AdditionalData data;
index 7abd387302aa9b21ab37a54f01d3d486fea891eb..f38f9361b3c6f7fe2bed9e0f03b2bc69f8e4fe4c 100644 (file)
@@ -51,7 +51,7 @@ main(int argc, char **argv)
 {
   initlog();
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   ParameterHandler                             prm;
   SUNDIALS::ARKode<VectorType>::AdditionalData data;
index 6eaacbd6a77cd3206fba18a1e8fe14b8050dc2a8..f0c8f10a419d5700d30c4dd68051b9bff2f23ecc 100644 (file)
@@ -68,7 +68,7 @@ public:
     , kappa(_kappa)
     , out("output")
   {
-    typedef Vector<double> VectorType;
+    using VectorType = Vector<double>;
 
     time_stepper.reinit_vector = [&](VectorType &v) { v.reinit(2); };
 
index 0b616f1db4b76b8a88eeb712354e6aff77ce2e26..6e16c5ce8175b4a46b123506f41eef54aa6e479f 100644 (file)
@@ -37,7 +37,7 @@ main(int argc, char **argv)
   Utilities::MPI::MPI_InitFinalize mpi_initialization(
     argc, argv, numbers::invalid_unsigned_int);
 
-  typedef Vector<double> VectorType;
+  using VectorType = Vector<double>;
 
   SUNDIALS::KINSOL<VectorType>::AdditionalData data;
   ParameterHandler                             prm;
index ec5c05943c4d8447195cf1b6169197095fa98b76..3ed6180aa58bc67dd4cdb88e6b188447580557bd 100644 (file)
@@ -513,10 +513,10 @@ test_functions()
   FullMatrix<number_t> D2psi_sd_sd(n_independent_variables,
                                    n_independent_variables);
   {
-    typedef SD::Expression SDNumberType;
+    using SDNumberType = SD::Expression;
 
     // Function and its derivatives
-    typedef FunctionStruct<SDNumberType> func_sd;
+    using func_sd = FunctionStruct<SDNumberType>;
 
     deallog.push("Symbolic computation: Function initialisation");
     const SDNumberType symb_s0("s1");
index 092cd8148eebcb79e3df67f45b3dc6f594681864..a05d29b44b56b20a35c877f8fd0d304c80bfda82 100644 (file)
@@ -39,7 +39,7 @@ test_scalar(const int n_runs, TimerOutput &timer)
   std::cout << std::string(80, '-') << std::endl;
   std::cout << "Scalar" << std::endl;
 
-  typedef SD::Expression SD_number_t;
+  using SD_number_t = SD::Expression;
 
   const NumberType  a = NumberType(1.5);
   const SD_number_t x("x");
index 3894ee522f22196cce4106712c72b9fc53ee5a57..9b7404e16713c11f2acf9fef96775d7a46f5a928 100644 (file)
@@ -32,8 +32,8 @@ template <int dim,
 void
 test_serialization()
 {
-  namespace SD = Differentiation::SD;
-  typedef SD::Expression SD_number_t;
+  namespace SD      = Differentiation::SD;
+  using SD_number_t = SD::Expression;
 
   // Serialization
   // Note: We scope all symbolic variables to make sure that they are
index b5f2df2353034f9ce6f5fd87b9c4468bd6981afc..f7e3f470ad720387ba065aafb58013788de41fd1 100644 (file)
@@ -340,7 +340,7 @@ evaluate_SD_SD_stored_symbols_optimisation(const Tensor<2, dim> &t,
                                            const Tensor<1, dim> &v,
                                            const double &        s)
 {
-  typedef SD::Expression SDNumberType;
+  using SDNumberType = SD::Expression;
 
   // Compute the symbolic (derivative) tensors once off
   // ahead of time, and store them for each run of the function
@@ -373,7 +373,7 @@ evaluate_SD_SD_stored_symbols_optimisation(const Tensor<2, dim> &t,
   if (symbols_initialised == false)
     {
       // Function and its derivatives
-      typedef CoupledFunction<dim, SDNumberType> func_sd;
+      using func_sd = CoupledFunction<dim, SDNumberType>;
 
       symb_psi = func_sd::psi(symb_t, symb_v, symb_s);
 #if DEBUG_EXTRA
@@ -484,8 +484,8 @@ evaluate_SD_SD_stored_symbols_optimisation(const Tensor<2, dim> &t,
   const double d2psi_ds_ds = optimizer.evaluate(symb_d2psi_ds_ds);
 
   // Verify the result
-  typedef CoupledFunction<dim, double> func;
-  static const double                  tol = 1e-12;
+  using func              = CoupledFunction<dim, double>;
+  static const double tol = 1e-12;
   Assert(std::abs(psi - func::psi(t, v, s)) < tol,
          ExcMessage("No match for function value."));
   Assert(std::abs((dpsi_dt - func::dpsi_dt(t, v, s)).norm()) < tol,
index 5a904d75a8a01d1341bc85ffc8c8a8de9d8ce298..bc81e2167c07046f20fb43c7a2e2a60953ef3285 100644 (file)
@@ -48,11 +48,11 @@ template <typename NumberType>
 void
 test_number_functions()
 {
-  typedef SD::Expression                SD_number_t;
-  typedef SE::RCP<const SE::RealDouble> SE_double_t;
-  // typedef SD_number_t result_t;
-  typedef NumberType result_t;
-  typedef double     float_result_t;
+  using SD_number_t = SD::Expression;
+  using SE_double_t = SE::RCP<const SE::RealDouble>;
+  // using result_t = SD_number_t;
+  using result_t       = NumberType;
+  using float_result_t = double;
 
   // Primitive numbers
   const NumberType x_(NumberType(2.2));
index 604883981532426b7181636014fcc3f30faf39a5..94159681e8602c8e5958d2d8dc54fa3439755667 100644 (file)
@@ -49,9 +49,9 @@ template <int dim, typename NumberType>
 void
 test_tensor()
 {
-  typedef SD::Expression                       SD_number_t;
-  typedef Tensor<2, dim, SD_number_t>          SD_tensor_t;
-  typedef SymmetricTensor<2, dim, SD_number_t> SD_symm_tensor_t;
+  using SD_number_t      = SD::Expression;
+  using SD_tensor_t      = Tensor<2, dim, SD_number_t>;
+  using SD_symm_tensor_t = SymmetricTensor<2, dim, SD_number_t>;
 
   // --- Values ---
   deallog.push("Initialize");
index 0afe4a26c29b7bf5f4deba2d51b2562cd28d7bbc..77a6117ea44b7ea94b6014940aac1a4b28f482e6 100644 (file)
@@ -28,7 +28,7 @@ template <int dim>
 void
 check()
 {
-  typedef SymmetricTensor<2, dim> S;
+  using S = SymmetricTensor<2, dim>;
   for (unsigned int i = 0; i < S::n_independent_components; ++i)
     {
       deallog << i << "  --  " << S::unrolled_to_component_indices(i)
index 28076f8359485a97d26949ab74458f6c2190076b..fe525f5d65147f644561d847af9e4c93306d5785 100644 (file)
@@ -28,7 +28,7 @@ template <int dim>
 void
 check()
 {
-  typedef Tensor<2, dim> S;
+  using S = Tensor<2, dim>;
   for (unsigned int i = 0; i < S::n_independent_components; ++i)
     {
       deallog << i << "  --  " << S::unrolled_to_component_indices(i)
index 607151013f3be6b3ca72f3811edee5f8993cb17a..ee790fb55e1781f7640d05c096768bb14ecd13b4 100644 (file)
@@ -27,8 +27,8 @@ template <int dim>
 void
 check()
 {
-  typedef Tensor<3, dim> T;
-  T                      t;
+  using T = Tensor<3, dim>;
+  T t;
   for (unsigned int i = 0; i < T::n_independent_components; ++i)
     t[T::unrolled_to_component_indices(i)] = (i + 1) * (i + 2);
 
index 620c16598b6b68ca2226ffe52c53045f3ab9964c..da033b9bb319fc6d114f5a23bccf5f639b02d87c 100644 (file)
@@ -27,19 +27,19 @@ test_symmetric()
 {
   constexpr int dim = 3;
 
-  typedef std::complex<double>                   rank0_complex;
+  using rank0_complex = std::complex<double>;
   dealii::Tensor<1, dim, rank0_complex>          curl_complex;
   dealii::SymmetricTensor<2, dim, rank0_complex> permeability_complex;
 
-  typedef std::complex<float>                 rank0_complex_float;
+  using rank0_complex_float = std::complex<float>;
   dealii::Tensor<1, dim, rank0_complex_float> curl_complex_float;
   dealii::Tensor<2, dim, rank0_complex_float> permeability_complex_float;
 
-  typedef double                rank0;
+  using rank0 = double;
   dealii::Tensor<1, dim, rank0> curl;
   dealii::Tensor<2, dim, rank0> permeability;
 
-  typedef double                      rank0_float;
+  using rank0_float = double;
   dealii::Tensor<1, dim, rank0_float> curl_float;
   dealii::Tensor<2, dim, rank0_float> permeability_float;
 
@@ -135,20 +135,20 @@ template <int dim>
 void
 test()
 {
-  typedef std::complex<double>                         rank0_complex;
+  using rank0_complex = std::complex<double>;
   dealii::Tensor<1, dim == 2 ? 1 : dim, rank0_complex> curl_complex;
   dealii::Tensor<dim == 2 ? 0 : 2, dim, rank0_complex> permeability_complex;
 
-  typedef std::complex<float> rank0_complex_float;
+  using rank0_complex_float = std::complex<float>;
   dealii::Tensor<1, dim == 2 ? 1 : dim, rank0_complex_float> curl_complex_float;
   dealii::Tensor<dim == 2 ? 0 : 2, dim, rank0_complex_float>
     permeability_complex_float;
 
-  typedef double                               rank0;
+  using rank0 = double;
   dealii::Tensor<1, dim == 2 ? 1 : dim, rank0> curl;
   dealii::Tensor<dim == 2 ? 0 : 2, dim, rank0> permeability;
 
-  typedef double                                     rank0_float;
+  using rank0_float = double;
   dealii::Tensor<1, dim == 2 ? 1 : dim, rank0_float> curl_float;
   dealii::Tensor<dim == 2 ? 0 : 2, dim, rank0_float> permeability_float;
 
index 37dcf6cc0dbee6b44f1d331bb9a623fae292a3fa..e21f8e0e9188cca60b06619c5a4eafa115664d16 100644 (file)
@@ -263,8 +263,8 @@ LaplaceProblem<dim>::setup_system()
                                            constraints);
   constraints.close();
 
-  typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-             CellFilter;
+  using CellFilter =
+    FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
   CellFilter begin(IteratorFilters::LocallyOwnedCell(),
                    dof_handler.begin_active());
   CellFilter end(IteratorFilters::LocallyOwnedCell(), dof_handler.end());
index 0a1dcc871bdba21555e570a8de321281b9b0d789..03448f2f79d2fe048e26faeae4f7f3b841d63ff9 100644 (file)
@@ -264,8 +264,8 @@ LaplaceProblem<dim>::setup_system()
                                            constraints);
   constraints.close();
 
-  typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-             CellFilter;
+  using CellFilter =
+    FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
   CellFilter begin(IteratorFilters::LocallyOwnedCell(),
                    dof_handler.begin_active());
   CellFilter end(IteratorFilters::LocallyOwnedCell(), dof_handler.end());
index 6754c869ffd4bc97b54d9ed977834f3d23034a5b..f863a86432f8e9fde089d6973021b6b54b2f8de2 100644 (file)
@@ -268,8 +268,8 @@ LaplaceProblem<dim>::setup_system()
                                            constraints);
   constraints.close();
 
-  typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-             CellFilter;
+  using CellFilter =
+    FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
   CellFilter begin(IteratorFilters::LocallyOwnedCell(),
                    dof_handler.begin_active());
   CellFilter end(IteratorFilters::LocallyOwnedCell(), dof_handler.end());
index d8bc60e668a0fe60585f18f109bd117079864fb4..92232593cec2408732e93d04aae306246b2a0873 100644 (file)
@@ -265,8 +265,8 @@ LaplaceProblem<dim>::setup_system()
                                            constraints);
   constraints.close();
 
-  typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-             CellFilter;
+  using CellFilter =
+    FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
   CellFilter begin(IteratorFilters::LocallyOwnedCell(),
                    dof_handler.begin_active());
   CellFilter end(IteratorFilters::LocallyOwnedCell(), dof_handler.end());
index 418d2251404597eb89c53d7d5ef5c8df107dbdc6..43e6d661736f2e1a6cb521b0dd64589e1c7b532c 100644 (file)
@@ -270,8 +270,8 @@ LaplaceProblem<dim>::setup_system()
                                            constraints);
   constraints.close();
 
-  typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-             CellFilter;
+  using CellFilter =
+    FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
   CellFilter begin(IteratorFilters::LocallyOwnedCell(),
                    dof_handler.begin_active());
   CellFilter end(IteratorFilters::LocallyOwnedCell(), dof_handler.end());
index 745d879275e52b8f1c7a5317c75a13dab967cec4..8b3a8260ae3536e3ecb088c75da122c2d2b94ade 100644 (file)
@@ -264,8 +264,8 @@ LaplaceProblem<dim>::setup_system()
                                            constraints);
   constraints.close();
 
-  typedef FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>
-             CellFilter;
+  using CellFilter =
+    FilteredIterator<typename DoFHandler<dim>::active_cell_iterator>;
   CellFilter begin(IteratorFilters::LocallyOwnedCell(),
                    dof_handler.begin_active());
   CellFilter end(IteratorFilters::LocallyOwnedCell(), dof_handler.end());
index fb17bccc1088f74dab55739d8a851688dc97eb11..f6df5557384e4142702d3534e64e72fe21536795 100644 (file)
@@ -30,8 +30,8 @@
 int
 main(int argc, char **argv)
 {
-  typedef BlockVector<double>                BlockVectorLocal;
-  typedef TrilinosWrappers::MPI::BlockVector BlockVector;
+  using BlockVectorLocal = BlockVector<double>;
+  using BlockVector      = TrilinosWrappers::MPI::BlockVector;
 
   Utilities::MPI::MPI_InitFinalize mpi_initialization(argc, argv, 1);
   MPILogInitAll                    log;
index 32e54edb0e6dc52fb961d230cf1e145c24f2b743..e7b908d59a81494f80c34cbfdf2dfcb00d5890d4 100644 (file)
@@ -55,7 +55,7 @@
 
 namespace PhaseField
 {
-  typedef Vector<double> vectorType;
+  using vectorType = Vector<double>;
 
 
   ///////////////////////////////////////////////////////////////

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.